Java Documentation Overview

/**
* This class tests that the game loop and screen handler are working correctly.
* All it does is display the current time in ms and display the number of
* frames per second.
*
* @author Luke Lindsay
*
*/
public class AnimationExpt extends JComponent {
private static final long serialVersionUID = 3690191057862473264L;
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
long l = System.currentTimeMillis();
String str = String.valueOf(l);
g.drawString(str, 100, 100);
}
public static void main(String[] args) {
System.setProperty("SHOWFPS", "true");
JFrame f = new JFrame();
f.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
f.getContentPane().add(new AnimationExpt());
ScreenHandler screenHandler = new ScreenHandler(f,
ScreenHandler.WINDOWED_MODE);
screenHandler.apply();
GameLoop gameLoop = new GameLoop(screenHandler);
Thread t = new Thread(gameLoop);
t.start();
}
}

/** Checks that all class that implement FreerailsSerializable are immutable and override equals and hashcode.
*
*
*/
public class CheckFreerailsSerializableClasses {
static final HashSet<Class> immutableTypes = new HashSet<Class>();
static final HashSet<Class> mutableTypes = new HashSet<Class>();
static Logger logger = Logger.getLogger(CheckFreerailsSerializableClasses.class
.getName());
public static void main(String[] args) {
immutableTypes.clear();
mutableTypes.clear();
immutableTypes.add(String.class);
// Class clazz = StationModel.class;
// System.err.println(overridesHashCodeAndEquals(clazz));
// System.out.println(clazz.isAnnotationPresent(InstanceControlled.class));
// Annotation[] ans = clazz.getAnnotations();
// for (Annotation an : ans) {
// System.err.println(an);
// }
// System.err.println(checkFields(clazz));
testAllClasses();
for (Class c : mutableTypes) {
System.err.println(c.getName());
}
}
static boolean checkFields(Class<?> clazz) {
Field[] fields = clazz.getDeclaredFields();
boolean okSoFar = true;
boolean assertImmutable = clazz.isAnnotationPresent(Immutable.class);
for (Field field : fields) {
int modifiers = field.getModifiers();
if (Modifier.isStatic(modifiers)) {
logger.fine("Skipping static field " + field.getName());
continue;
}
Class<?> type = field.getType();
if (type.isPrimitive()) {
continue;
}
// if(!Modifier.isPrivate(modifiers)){
// System.err.println(clazz.getName()+field.getName()+" should be
// private!");
// okSoFar = false;
// }
if (!FreerailsSerializable.class.isAssignableFrom(type)
&& !assertImmutable) {
if (!immutableTypes.contains(type) && !type.isEnum()
&& !type.isAnnotationPresent(Immutable.class)) {
System.err.println(clazz.getName() + "." + field.getName()
+ " {" + type.getName()
+ "} might not be immutable!");
okSoFar = false;
if (!type.isArray())
mutableTypes.add(type);
}
}
}
return okSoFar;
}
@SuppressWarnings("unchecked")
static void testAllClasses() {
ClassLocater locater = new ClassLocater();
Class[] classes = locater.getSubclassesOf(FreerailsSerializable.class);
int classesWithProblems = 0;
for (Class clazz : classes) {
if (clazz.isInterface()) {
logger.fine("Skipping interface " + clazz.getName());
continue;
}
int mods = clazz.getModifiers();
if ((mods & Modifier.ABSTRACT) != 0) {
logger.fine("Skipping abstract class " + clazz.getName());
continue;
}
if (clazz.isAnnotationPresent(InstanceControlled.class)) {
logger.fine("Skipping InstanceControlled class "
+ clazz.getName());
continue;
}
boolean b = overridesHashCodeAndEquals(clazz);
b = b && checkFields(clazz);
if (!b) {
classesWithProblems++;
}
}
System.err.println(classes.length + " classes checked, "
+ classesWithProblems + " have problems");
}
static boolean overridesHashCodeAndEquals(Class clazz) {
try {
boolean okSoFar = true;
Method equals = clazz.getMethod("equals", Object.class);
if (equals.getDeclaringClass().equals(Object.class)) {
System.err.println(clazz.getName() + " does not override "
+ equals.getName());
okSoFar = false;
}
Method hashCode = clazz.getMethod("hashCode");
if (hashCode.getDeclaringClass().equals(Object.class)) {
System.err.println(clazz.getName() + " does not override "
+ hashCode.getName());
okSoFar = false;
}
return okSoFar;
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return false;
}
}

/**
*
* @author Luke
*/
public class ConnectAllCities {
static class DistanceComparator implements Comparator<CityModel> {
final int targetX, targetY;
public DistanceComparator(int targetX, int targetY) {
this.targetX = targetX;
this.targetY = targetY;
}
int distSquared(CityModel a) {
int xDist = a.getCityX() - targetX;
int yDist = a.getCityY() - targetY;
return xDist * xDist + yDist * yDist;
}
@Override
public int compare(CityModel a, CityModel b) {
return distSquared(a) - distSquared(b);
}
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) throws IOException, PathNotFoundException {
SavedGamesManager gamesManager = new SavedGamesManagerImpl();
String[] newMapNames = gamesManager.getNewMapNames();
World w = (World) gamesManager.newMap(newMapNames[0]);
System.out.println(w.getClass());
ServerGameModel gameModel = new ServerGameModelImpl();
String name = "Tester";
Player p = new Player(name, 0);
Move addPlayerMove = AddPlayerMove.generateMove(w, p);
MoveStatus ms = addPlayerMove.doMove(w, Player.AUTHORITATIVE);
w.set(ITEM.CALENDAR, new GameCalendar(1200, 1840));
w.setTime(new GameTime(0));
w.set(ITEM.GAME_SPEED, new GameSpeed(10));
w.set(ITEM.GAME_RULES, GameRules.DEFAULT_RULES);
Transaction t = new AddItemTransaction(Transaction.Category.BOND, 0, 1, new Money(50000000));
w.addTransaction(p.getPrincipal(), t);
List<CityModel> citiesUnconnected = new ArrayList<>();
List<CityModel> citiesConnected = new ArrayList<>();
int nCities = w.size(SKEY.CITIES);
System.out.format("There are %d cities.%n", nCities);
for (int i = 0; i < nCities; i++) {
citiesUnconnected.add((CityModel) w.get(SKEY.CITIES, i));
}
CityModel cityA = citiesUnconnected.remove(0);
citiesConnected.add(cityA);
DistanceComparator distanceComparator = new DistanceComparator(cityA.getCityX(), cityA.getCityY());
Collections.sort(citiesUnconnected, distanceComparator);
MapCustomizer mc = new MapCustomizer(w);
int n = citiesUnconnected.size();
for (int i = 0; i < n; i++) {
CityModel cityB = citiesUnconnected.remove(0);
System.out.format("build track to %s%n", cityB.getCityName());
distanceComparator = new DistanceComparator(cityB.getCityX(), cityB.getCityY());
Collections.sort(citiesConnected, distanceComparator);
ImPoint b = cityB.getLocation();
for (int j = 0; j < Math.min(3, citiesConnected.size()); j++) {
cityA = citiesConnected.get(j);
ImPoint a = cityA.getLocation();
mc.buildTrack(a, b);
try {
if (j == 0) {
if (i == 0) {
mc.buildStation(a);
}
mc.buildStation(b);
}
} catch (java.lang.IllegalStateException e) {
//sometimes it is not possible to build the
//stations, e.g. another one is too close.
break;
}
int stationA = mc.getStationId(a);
int stationB = mc.getStationId(b);
if (stationA >= 0 && stationB >= 0) {
//the stations exist.
mc.buildTrain(b, stationA, stationB);
}
}
System.out.format("There are %d stations%n", w.size(p.getPrincipal(), KEY.STATIONS));
citiesConnected.add(cityB);
}
System.out.println(ms);
String[] passwords = {"password"};
gameModel.setWorld(w, passwords);
gamesManager.saveGame(gameModel, "generated.sav");
}
}

/**
* This class lets you test dialogue boxes without running the whole game.
*
* @author lindsal8
*
*/
public class DialogueBoxTester extends javax.swing.JFrame {
private static final long serialVersionUID = 4050764909631780659L;
private static final Player TEST_PLAYER = new Player("test player", 0);
private static final FreerailsPrincipal TEST_PRINCIPAL = TEST_PLAYER
.getPrincipal();
private final DialogueBoxController dialogueBoxController;
private World w;
private RenderersRoot vl;
private ModelRootImpl modelRoot;
private Action closeCurrentDialogue = new AbstractAction("Close") {
private static final long serialVersionUID = 1L;
public void actionPerformed(ActionEvent arg0) {
dialogueBoxController.closeContent();
}
};
;
private TrainDialogueJPanel trainDialogueJPanel = new TrainDialogueJPanel();
/** Creates new form TestGlassPanelMethod. */
private DialogueBoxTester() {
w = new WorldImpl(200, 200);
UntriedMoveReceiver dummyReceiver = new SimpleMoveReceiver(w);
modelRoot = new ModelRootImpl();
modelRoot.setMoveFork(new MoveChainFork());
modelRoot.setMoveReceiver(dummyReceiver);
WagonAndEngineTypesFactory wetf = new WagonAndEngineTypesFactory();
TileSetFactory tileFactory = new TileSetFactoryImpl();
tileFactory.addTerrainTileTypesList(w);
wetf.addTypesToWorld(w);
w.addPlayer(TEST_PLAYER);
try {
vl = new RenderersRootImpl(w, FreerailsProgressMonitor.NULL_INSTANCE);
} catch (IOException e) {
e.printStackTrace();
}
modelRoot.setup(w, TEST_PLAYER.getPrincipal());
ActionRoot actionRoot = new ActionRoot(modelRoot);
actionRoot.setup(modelRoot, vl);
dialogueBoxController = new DialogueBoxController(this, modelRoot);
actionRoot.setDialogueBoxController(dialogueBoxController);
dialogueBoxController.setDefaultFocusOwner(this);
int numberOfCargoTypes = w.size(SKEY.CARGO_TYPES);
StationModel bristol = new StationModel(10, 10, "Bristol",
numberOfCargoTypes, 0);
boolean[] demandArray = new boolean[numberOfCargoTypes];
// Make the stations demand all cargo..
for (int i = 0; i < demandArray.length; i++) {
demandArray[i] = true;
}
Demand4Cargo demand = new Demand4Cargo(demandArray);
bristol = new StationModel(bristol, demand);
w.add(TEST_PRINCIPAL, KEY.STATIONS, bristol);
w.add(TEST_PRINCIPAL, KEY.STATIONS, new StationModel(50, 100, "Bath",
numberOfCargoTypes, 0));
w.add(TEST_PRINCIPAL, KEY.STATIONS, new StationModel(40, 10, "Cardiff",
numberOfCargoTypes, 0));
w.add(TEST_PRINCIPAL, KEY.STATIONS, new StationModel(100, 10, "London",
numberOfCargoTypes, 0));
w.add(TEST_PRINCIPAL, KEY.STATIONS, new StationModel(90, 50, "Swansea",
numberOfCargoTypes, 0));
// Set up cargo bundle, for the purpose of this test code all the trains
// can share the
// same one.
MutableCargoBundle cb = new MutableCargoBundle();
cb.setAmount(new CargoBatch(0, 10, 10, 8, 0), 80);
cb.setAmount(new CargoBatch(0, 10, 10, 9, 0), 60);
cb.setAmount(new CargoBatch(1, 10, 10, 9, 0), 140);
cb.setAmount(new CargoBatch(3, 10, 10, 9, 0), 180);
cb.setAmount(new CargoBatch(5, 10, 10, 9, 0), 10);
w.add(TEST_PRINCIPAL, KEY.CARGO_BUNDLES, cb.toImmutableCargoBundle());
MutableSchedule schedule = new MutableSchedule();
TrainOrdersModel order = new TrainOrdersModel(0, new ImInts(0, 0, 0),
false, false);
TrainOrdersModel order2 = new TrainOrdersModel(1, new ImInts(1, 2, 0,
0, 0), true, false);
TrainOrdersModel order3 = new TrainOrdersModel(2, null, true, false);
schedule.setOrder(0, order);
schedule.setOrder(1, order2);
int scheduleID = w.add(TEST_PRINCIPAL, KEY.TRAIN_SCHEDULES, schedule
.toImmutableSchedule());
w.add(TEST_PRINCIPAL, KEY.TRAINS,
new TrainModel(0, new ImInts(0, 0), scheduleID));
schedule.setOrder(2, order2);
schedule.setOrder(3, order3);
scheduleID = w.add(TEST_PRINCIPAL, KEY.TRAIN_SCHEDULES,
schedule.toImmutableSchedule());
w.add(TEST_PRINCIPAL, KEY.TRAINS,
new TrainModel(1, new ImInts(1, 1), scheduleID));
schedule.setOrder(4, order2);
schedule.setOrderToGoto(3);
schedule.setPriorityOrders(order);
scheduleID = w.add(TEST_PRINCIPAL, KEY.TRAIN_SCHEDULES,
schedule.toImmutableSchedule());
w.add(TEST_PRINCIPAL, KEY.TRAINS,
new TrainModel(0, new ImInts(1, 2, 0), scheduleID));
final MyGlassPanel glassPanel = new MyGlassPanel();
dialogueBoxController.setup(modelRoot, vl);
initComponents();
glassPanel.setSize(800, 600);
this.addComponentListener(new JFrameMinimumSizeEnforcer(640, 480));
this.setSize(640, 480);
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the FormEditor.
*/
private void initComponents() {// GEN-BEGIN:initComponents
jLabel1 = new javax.swing.JLabel();
jMenuBar1 = new javax.swing.JMenuBar();
show = new javax.swing.JMenu();
showBrokerScreen = new javax.swing.JMenuItem();
selectEngine = new javax.swing.JMenuItem();
selectWagons = new javax.swing.JMenuItem();
selectTrainOrders = new javax.swing.JMenuItem();
showControls = new javax.swing.JMenuItem();
showTerrainInfo = new javax.swing.JMenuItem();
showStationInfo = new javax.swing.JMenuItem();
showTrainList = new javax.swing.JMenuItem();
showReportBug = new javax.swing.JMenuItem();
throwException = new javax.swing.JMenuItem();
showCargoWaitingAndDemand = new javax.swing.JMenuItem();
showJavaSystemProperties = new javax.swing.JMenuItem();
showNetworthGraph = new javax.swing.JMenuItem();
addKeyListener(new java.awt.event.KeyAdapter() {
@Override
public void keyPressed(java.awt.event.KeyEvent evt) {
formKeyPressed(evt);
}
});
addWindowListener(new java.awt.event.WindowAdapter() {
@Override
public void windowClosing(java.awt.event.WindowEvent evt) {
exitForm(evt);
}
});
jLabel1.setIcon(new javax.swing.ImageIcon(getClass().getResource(
"/jfreerails/data/south_america.png")));
jLabel1.setText("Press Esc to close dialogue boxes");
jLabel1.setMinimumSize(new java.awt.Dimension(640, 480));
jLabel1.setPreferredSize(new java.awt.Dimension(640, 480));
getContentPane().add(jLabel1, java.awt.BorderLayout.CENTER);
show.setText("Show");
showBrokerScreen.setText("Broker Screen");
showBrokerScreen.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
newspaperActionPerformed(evt);
}
});
show.add(showBrokerScreen);
selectEngine.setText("Select Engine");
selectEngine.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
selectEngineActionPerformed(evt);
}
});
show.add(selectEngine);
selectWagons.setText("Select Wagons");
selectWagons.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
selectWagonsActionPerformed(evt);
}
});
show.add(selectWagons);
selectTrainOrders.setText("Train Orders");
selectTrainOrders
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
selectTrainOrdersActionPerformed(evt);
}
});
show.add(selectTrainOrders);
showControls.setText("Show game controls");
showControls.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
showControlsActionPerformed(evt);
}
});
show.add(showControls);
showTerrainInfo.setText("Show Terrain Info");
showTerrainInfo.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
showTerrainInfoActionPerformed(evt);
}
});
show.add(showTerrainInfo);
showStationInfo.setText("Show Station Info");
showStationInfo.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
showStationInfoActionPerformed(evt);
}
});
show.add(showStationInfo);
showTrainList.setText("Train List");
showTrainList.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
showTrainListActionPerformed(evt);
}
});
show.add(showTrainList);
showCargoWaitingAndDemand.setText("Cargo waiting & demand");
showCargoWaitingAndDemand
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
showCargoWaitingAndDemandActionPerformed(evt);
}
});
show.add(showCargoWaitingAndDemand);
showJavaSystemProperties.setText("Java System Properties");
showJavaSystemProperties
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
showJavaSystemPropertiesActionPerformed(evt);
}
});
throwException.setText("Throw Exception");
throwException.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
throw new IllegalArgumentException();
}
});
show.add(showJavaSystemProperties);
showNetworthGraph.setText("Show networth graph");
showNetworthGraph
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
showNetworthGraphActionPerformed(evt);
}
});
show.add(showNetworthGraph);
showReportBug.setText("Report Bug");
showReportBug
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
dialogueBoxController.showReportBug();
}
});
show.add(showReportBug);
jMenuBar1.add(show);
setJMenuBar(jMenuBar1);
}// GEN-END:initComponents
private void showNetworthGraphActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_showNetworthGraphActionPerformed
dialogueBoxController.showNetworthGraph();
}// GEN-LAST:event_showNetworthGraphActionPerformed
private void showJavaSystemPropertiesActionPerformed(
java.awt.event.ActionEvent evt) {// GEN-FIRST:event_showJavaSystemPropertiesActionPerformed
// Add your handling code here:
String s = ShowJavaProperties.getPropertiesHtmlString();
HtmlJPanel htmlPanel = new HtmlJPanel(s);
htmlPanel.setup(modelRoot, vl, closeCurrentDialogue);
dialogueBoxController.showContent(htmlPanel);
}// GEN-LAST:event_showJavaSystemPropertiesActionPerformed
private void formKeyPressed(java.awt.event.KeyEvent evt) {// GEN-FIRST:event_formKeyPressed
if (java.awt.event.KeyEvent.VK_ESCAPE == evt.getKeyCode()) {
dialogueBoxController.closeContent();
}
}// GEN-LAST:event_formKeyPressed
private void showCargoWaitingAndDemandActionPerformed(
java.awt.event.ActionEvent evt) {// GEN-FIRST:event_showCargoWaitingAndDemandActionPerformed
// Add your handling code here:
CargoWaitingAndDemandedJPanel panel = new CargoWaitingAndDemandedJPanel();
panel.setup(modelRoot, vl, closeCurrentDialogue);
int newStationID = 0;
panel.display(newStationID);
dialogueBoxController.showContent(panel);
}// GEN-LAST:event_showCargoWaitingAndDemandActionPerformed
private void showTrainListActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_showTrainListActionPerformed
// Add your handling code here:
dialogueBoxController.showTrainList();
}// GEN-LAST:event_showTrainListActionPerformed
private void showStationInfoActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_showStationInfoActionPerformed
// Add your handling code here:
int stationNumber = 0;
dialogueBoxController.showStationInfo(stationNumber);
}// GEN-LAST:event_showStationInfoActionPerformed
private void showTerrainInfoActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_showTerrainInfoActionPerformed
// Add your handling code here:
int terrainType = 0;
dialogueBoxController.showTerrainInfo(terrainType);
}// GEN-LAST:event_showTerrainInfoActionPerformed
private void showControlsActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_showControlsActionPerformed
// Add your handling code here:
dialogueBoxController.showGameControls();
}// GEN-LAST:event_showControlsActionPerformed
private void selectTrainOrdersActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_selectTrainOrdersActionPerformed
// Add your handling code here:
trainDialogueJPanel.setup(modelRoot, vl, closeCurrentDialogue);
trainDialogueJPanel.display(0);
dialogueBoxController.showContent(trainDialogueJPanel);
}// GEN-LAST:event_selectTrainOrdersActionPerformed
private void selectWagonsActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_selectWagonsActionPerformed
// Add your handling code here:
dialogueBoxController.showSelectWagons();
}// GEN-LAST:event_selectWagonsActionPerformed
private void selectEngineActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_selectEngineActionPerformed
// Add your handling code here:
dialogueBoxController.showSelectEngine();
}// GEN-LAST:event_selectEngineActionPerformed
private void newspaperActionPerformed(java.awt.event.ActionEvent evt) { // GEN-FIRST:event_newspaperActionPerformed
// Add your handling code here:
dialogueBoxController.showBrokerScreen();
//dialogueBoxController.showNewspaper("New headline!");
}// GEN-LAST:event_newspaperActionPerformed
/** Exit the Application. */
private void exitForm(java.awt.event.WindowEvent evt) {// GEN-FIRST:event_exitForm
System.exit(0);
}// GEN-LAST:event_exitForm
public static void main(String args[]) {
DialogueBoxTester test = new DialogueBoxTester();
test.setVisible(true);
}
// Variables declaration - do not modify//GEN-BEGIN:variables
javax.swing.JLabel jLabel1;
javax.swing.JMenuBar jMenuBar1;
javax.swing.JMenuItem showBrokerScreen;
javax.swing.JMenuItem selectEngine;
javax.swing.JMenuItem selectTrainOrders;
javax.swing.JMenuItem selectWagons;
javax.swing.JMenu show;
javax.swing.JMenuItem showCargoWaitingAndDemand;
javax.swing.JMenuItem showControls;
javax.swing.JMenuItem showJavaSystemProperties;
javax.swing.JMenuItem showNetworthGraph;
javax.swing.JMenuItem showStationInfo;
javax.swing.JMenuItem showTerrainInfo;
javax.swing.JMenuItem showTrainList;
javax.swing.JMenuItem showReportBug;
javax.swing.JMenuItem throwException;
// End of variables declaration//GEN-END:variables
}

/**
* Experiment to try out reading and writing to a buffer to test serialization
* code.
*
* @author Luke
*
*/
public class ExptWriteToBuffer {
private static final Logger logger = Logger
.getLogger(ExptWriteToBuffer.class.getName());
public static void main(String[] args) {
try {
Point p = new Point(10, 10);
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream objectOut = new ObjectOutputStream(out);
objectOut.writeObject(p);
objectOut.flush();
byte[] bytes = out.toByteArray();
ByteArrayInputStream in = new ByteArrayInputStream(bytes);
ObjectInputStream objectIn = new ObjectInputStream(in);
Object o = objectIn.readObject();
Point p2 = (Point) o;
if (p.equals(p2)) {
logger.info("The two objects are equal!");
} else {
logger.info("The two objects are not equal!");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}

/**
* This class generates an ant script that checks the dependencies between
* packages and also generates an html page that illustrates the allowed
* dependencies. The checkdep target on the generated ant script tests the
* dependencies of packages. It does this by copying the contents of the package
* in question together with the contents of the packages it is allowed to
* depend on to a temporary directory, then compiling the contents of the
* package. If the packaged depends on classes other than those contained in the
* packages it is allowed to depend on, the compile will fail.
*
* @author Luke
*
*/
public class GenerateDependenciesXmlAndHtml {
private static final Logger logger = Logger
.getLogger(GenerateDependenciesXmlAndHtml.class.getName());
private PrintWriter xmlWriter;
private PrintWriter htmlWriter;
private ArrayList<String> packages = new ArrayList<String>();
private boolean started = false;
private boolean startedBlock = false;
private String sig;
public static void main(String[] args) {
try {
new GenerateDependenciesXmlAndHtml("checkdep.xml", "src"
+ File.separator + "docs" + File.separator
+ "dependencies.html");
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
private GenerateDependenciesXmlAndHtml(String xmlFilename,
String htmlFilename) throws FileNotFoundException {
Date d = new Date();
sig = this.getClass().getName() + " on " + d;
// Setup writers
File xmlFile = new File(xmlFilename);
xmlWriter = new PrintWriter(new FileOutputStream(xmlFile));
File htmlFile = new File(htmlFilename);
htmlWriter = new PrintWriter(new FileOutputStream(htmlFilename));
String[] basePackages = { "jfreerails/util/*" };
start();
startBlock("All");
add(basePackages);
add("jfreerails/world/**/*");
add("jfreerails/move/**/*");
add("jfreerails/controller/*");
add("jfreerails/network/*");
add(new String[] { "jfreerails/server/**/*", "jfreerails/client/**/*" });
add("jfreerails/launcher/**/*");
add("jfreerails/experimental/**/*");
endBlock();
startBlock("World");
add(basePackages);
add("jfreerails/world/common/*");
add(new String[] { "jfreerails/world/terrain/*",
"jfreerails/world/cargo/*", "jfreerails/world/train/*",
"jfreerails/world/station/*" });
add("jfreerails/world/track/*");
add("jfreerails/world/accounts/*");
add("jfreerails/world/player/*");
add("jfreerails/world/top/*");
endBlock();
startBlock("Server");
add(basePackages);
add("jfreerails/world/**/*");
add("jfreerails/move/**/*");
add("jfreerails/controller/*");
add("jfreerails/network/*");
add("jfreerails/server/common/*");
add("jfreerails/server/parser/*");
add("jfreerails/server/*");
endBlock();
startBlock("Client");
add(basePackages);
add("jfreerails/world/**/*");
add("jfreerails/move/**/*");
add("jfreerails/controller/*");
add("jfreerails/network/*");
add("jfreerails/client/common/*");
add("jfreerails/client/renderer/*");
add("jfreerails/client/view/*");
add("jfreerails/client/top/*");
endBlock();
finish();
xmlWriter.flush();
htmlWriter.flush();
logger.info(sig);
logger.info("Wrote " + xmlFile);
logger.info("Wrote " + htmlFile);
}
private void start() {
assert !started;
startXml();
htmlWriter.write("<html>\n");
htmlWriter.write("<title>Dependencies between packages</title>\n");
htmlWriter.write("<p><code>This file was generate by " + sig
+ "</code></p>\n");
htmlWriter.write("<h1>Dependencies between packages</h1>\n");
htmlWriter
.write("<p>The figures below show the dependencies: packages may only depend, i.e. import classes and interfaces, from packages below.</p>\n");
started = true;
}
private void startBlock(String blockName) {
assert started;
assert !startedBlock;
startedBlock = true;
htmlWriter.write("<h2>" + blockName + "</h2>");
xmlWriter
.write("\n\t\t<!-- Setup the directory where the legal dependencies are stored -->\n");
xmlWriter.write("\t\t<delete dir=\"dependencies\" />\n");
xmlWriter.write("\t\t<mkdir dir=\"dependencies\" />\n");
}
private void endBlock() {
assert started;
assert startedBlock;
htmlWriter
.write("<table width=\"100%\" border=\"1\" cellpadding=\"10\" cellspacing=\"10\" bordercolor=\"#333333\" bgcolor=\"#FFFFFF\">\n");
for (int i = packages.size() - 1; i >= 0; i--) {
String packageName = packages.get(i);
htmlWriter.write("<tr bgcolor=\"#FFCCCC\"> \n");
htmlWriter.write("<td height=\"50\" bgcolor=\"#FFCC66\">"
+ packageName + "</td>\n");
htmlWriter.write("</tr>\n");
}
htmlWriter.write("</table>\n");
packages.clear();
xmlWriter.write("\n\t\t<!-- End Block -->\n");
xmlWriter.write("\t\t<echo message=\"End Block\"/>\n");
startedBlock = false;
}
private void startXml() {
// Start the file.
xmlWriter.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
xmlWriter
.write("<project basedir=\".\" default=\"checkdep\" name=\"checkdep\">\n");
xmlWriter.write("\t<description>This ant script was generated by "
+ sig
+ " to check the dependencies for jfreerails.</description>\n");
// Set the properties.
// Add the compile target.
xmlWriter
.write("\n\t<target description=\"Build everything except JUnit test-classes\" name=\"compile\">\n");
xmlWriter.write("\t\t<mkdir dir=\"build\" />\n");
xmlWriter
.write("\t\t<javac destdir=\"build\" fork=\"true\" srcdir=\"src\" source=\"1.5\">\n");
xmlWriter.write("\t\t\t<exclude name=\"**/*Test.java\" />\n");
xmlWriter.write("\t\t </javac>\n");
xmlWriter.write("\t</target>\n");
// Start the check depend target.
xmlWriter
.write("\n\n\t<target depends=\"compile\" description=\"Tests whether dependencies between packages conform to the rules defined in this target\" name=\"checkdep\">\n");
}
private void add(String packageName) {
add(new String[] { packageName });
}
private void add(String[] packageNames) {
assert started;
assert startedBlock;
String packagesString = "";
for (int i = packageNames.length - 1; i > 0; i--) {
packagesString += convertToPackageName(packageNames[i]) + ", ";
}
packagesString += " " + convertToPackageName(packageNames[0]);
// The html writer will use this later.
packages.add(packagesString);
xmlWriter.write("\n\t\t<!-- New row: " + packagesString + " -->\n");
xmlWriter.write("\t\t<echo message=\"New row: " + packagesString
+ "\"/>\n");
// Include the source files we are going to compile.
for (String packageName : packageNames) {
xmlWriter.write("\t\t<echo message=\"Check dependencies for "
+ packageName + "\"/>\n");
xmlWriter.write("\t\t<delete dir=\"temp\" />\n");
xmlWriter.write("\t\t<mkdir dir=\"temp\" />\n");
// First copy the files we are testing.
xmlWriter.write("\t\t<copy todir=\"temp\">\n");
xmlWriter.write("\t\t<fileset dir=\"src\">\n");
xmlWriter.write("\t\t\t<include name=\"" + packageName
+ ".java\" />\n");
// Exclude unit tests.
xmlWriter.write("\t\t\t<exclude name=\"**/*Test.java\" />\n");
xmlWriter.write("\t\t</fileset>\n");
xmlWriter.write("\t\t</copy>\n");
xmlWriter
.write("\t\t<javac fork=\"true\" srcdir=\"temp\" source=\"1.5\" classpath=\"dependencies\">\n");
// Include the files we are going to compile.
xmlWriter.write("\t\t\t<include name=\"" + packageName
+ ".java\" />\n");
xmlWriter.write("\t\t</javac>\n");
xmlWriter.write("\t\t<delete dir=\"temp\" />\n");
}
// Copy the files we have just tested to the dependencies directory.
xmlWriter.write("\t\t<copy todir=\"dependencies\">\n");
xmlWriter.write("\t\t<fileset dir=\"build\">\n");
for (int i = 0; i < packageNames.length; i++) {
xmlWriter.write("\t\t\t<include name=\"" + packageNames[i]
+ ".class\" />\n");
}
xmlWriter.write("\t\t\t<exclude name=\"**/*Test.class\" />\n");
xmlWriter.write("\t\t</fileset>\n");
xmlWriter.write("\t\t</copy>\n");
}
private String convertToPackageName(String packagesString) {
if (!isPackageNameOk(packagesString)) {
throw new IllegalArgumentException(packagesString);
}
packagesString = packagesString.replace('/', '.');
/*
* Remove the last two characters, so that jfreerails.world.**.* - >
* jfreerails.world.** and jfreerails.util.* -> jfreerails.util
*/
packagesString = packagesString.substring(0,
packagesString.length() - 2);
return packagesString;
}
static boolean isPackageNameOk(String s) {
return s.matches("(([a-zA-Z]*)/)*\\*")
|| s.matches("(([a-zA-Z]*)/)*\\*\\*/\\*");
}
private void finish() {
assert started;
assert !startedBlock;
// finish the file.
xmlWriter.write("\t\t<delete dir=\"temp\" />\n");
xmlWriter.write("\t\t<delete dir=\"dependencies\" />\n");
xmlWriter.write("\t</target>\n");
xmlWriter.write("</project>\n");
htmlWriter.write("</html>\n");
started = false;
}
}

/**
* Generates image files that can be used to indicate that a train has focus or
* is selected. The image files are semi transparent and are intended to be
* rendered 'under' the images of the train's engine and wagons.
*
*
* @author Luke
*/
public class GenerateTrainHighlights {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
ImageManager imageManager = new ImageManagerImpl(
"/experimental/", "/experimental/");
UIDefaults lookAndFeelDefaults = UIManager.getLookAndFeelDefaults();
Color selection = (Color) lookAndFeelDefaults.get("List.selectionBackground");
selection = makeTransparent(selection, 128);
String filename = "selected_%s.png";
gen(imageManager, selection, filename);
Color focus = (Color) lookAndFeelDefaults.get("TabbedPane.focus");
focus = makeTransparent(focus, 128);
filename = "focused_%s.png";
gen(imageManager, focus, filename);
try {
imageManager.writeAllImages();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void gen(ImageManager imageManager, Color selection, String filename) {
for (Step step : Step.getList()) {
int tileSize = 30;
Image smallImage = imageManager.newBlankImage(tileSize, tileSize);
Graphics2D g2 = (Graphics2D) smallImage.getGraphics();
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
g2.setStroke(new BasicStroke(3));
double arcRadius = 5;
g2.rotate(step.getDirection(), tileSize/2, tileSize/2);
RoundRectangle2D roundedRectangle = new RoundRectangle2D.Double(7, 3, 16, 26, arcRadius, arcRadius);
g2.setColor(selection);
g2.fill(roundedRectangle);
g2.dispose();
String name = String.format(filename, step.toAbrvString());
imageManager.setImage(name, smallImage);
}
}
static Color makeTransparent(Color before, int alpha){
return new Color(before.getRed(), before.getGreen(), before.getBlue(), alpha);
}
}

/**
* This TrackPieceRenderer renders track pieces by drawing lines so avoids the
* need to load images.
*
* @author Luke Lindsay
*/
public class LineDrawTrackPieceView implements
jfreerails.client.renderer.TrackPieceRenderer {
private int[] xx = { -1, 0, 1, -1, 0, 1, -1, 0, 1 };
private int[] yy = { -1, -1, -1, 0, 0, 0, 1, 1, 1 };
public java.awt.Image getTrackPieceIcon(int trackTemplate) {
return null;
}
public void drawTrackPieceIcon(int trackTemplate, java.awt.Graphics g,
int x, int y, java.awt.Dimension tileSize) {
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(new java.awt.BasicStroke(8.0f));
g2.setColor(java.awt.Color.red);
if (0 != trackTemplate) {
int drawX = x * tileSize.width;
int drawY = y * tileSize.height;
// g.drawLine(drawX-10,drawY-10,drawX+10,drawY+10);
for (int i = 0; i < 9; i++) {
if ((trackTemplate & (1 << i)) == (1 << i)) {
g2.drawLine(drawX + 15, drawY + 15,
drawX + 15 + 15 * xx[i], drawY + 15 + 15 * yy[i]);
}
}
}
}
public void dumpImages(ImageManager imageManager) {
// TODO Auto-generated method stub
}
}

/**
* Tests that ClientJFrame and ScreenHandler work together.
*
* @author Luke Lindsay
*/
public class RunMe {
public static void main(String[] args) {
JFrame jFrame = new jfreerails.client.top.ClientJFrame(
new SimpleComponentFactoryImpl2());
// jFrame.show();
ScreenHandler screenHandler = new ScreenHandler(jFrame,
ScreenHandler.WINDOWED_MODE);
GameLoop gameLoop = new GameLoop(screenHandler);
Thread t = new Thread(gameLoop);
t.start();
}
}

/**
* This GUIComponentFactory creates simple components that can be used to test
* the layout of the client jFrame without running the whole game.
*
* @author Luke Lindsay
*/
public class SimpleComponentFactoryImpl2 implements
jfreerails.client.top.GUIComponentFactory {
private OverviewMapJComponent overviewMap;
private JScrollPane mainMapScrollPane1;
private MapViewJComponentConcrete mainMap;
private MainMapAndOverviewMapMediator mediator;
private Rectangle r = new Rectangle();
/** Creates new SimpleComponentFactoryImpl */
public SimpleComponentFactoryImpl2() {
}
public JMenu createBuildMenu() {
return new JMenu("Build");
}
public JMenu createGameMenu() {
return new JMenu("Game");
}
public JMenu createDisplayMenu() {
JMenu displayMenu = new JMenu("Display");
addMainmapzoomMenuItem(displayMenu, 5);
addMainmapzoomMenuItem(displayMenu, 10);
addOverviewmapzoomMenuItem(displayMenu, 0.2F);
addOverviewmapzoomMenuItem(displayMenu, 0.6F);
return displayMenu;
}
public JMenu createBrokerMenu() {
JMenu brokerMenu = new JMenu("Broker");
return brokerMenu;
}
private void addOverviewmapzoomMenuItem(JMenu displayMenu, final float scale) {
String menuItemName = "Set overview map scale=" + scale;
JMenuItem menuItem = new JMenuItem(menuItemName);
menuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
overviewMap.setup(new BlankMapRenderer(scale));
}
});
displayMenu.add(menuItem);
}
private void addMainmapzoomMenuItem(JMenu displayMenu, final float scale) {
String menuItemName = "Set main map scale=" + scale;
JMenuItem menuItem = new JMenuItem(menuItemName);
menuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Rectangle visRect = mainMap.getVisibleRect();
int oldWidth = mainMap.getWidth();
mainMap.setup(new BlankMapRenderer(scale));
int newWidth = mainMap.getPreferredSize().width;
int oldCenterX = visRect.x + (visRect.width / 2);
int newCenterX = oldCenterX * newWidth / oldWidth;
visRect.x = newCenterX - visRect.width / 2;
int oldCenterY = visRect.y + (visRect.height / 2);
int newCenterY = oldCenterY * newWidth / oldWidth;
visRect.y = newCenterY - visRect.height / 2;
/*
* LL: I'm not sure why the 'if' is necessary in the following,
* but the view does not center on the right spot without it.
*/
if (oldWidth < newWidth) {
mainMap.setSize(mainMap.getPreferredSize());
mainMap.scrollRectToVisible(visRect);
} else {
mainMap.scrollRectToVisible(visRect);
mainMap.setSize(mainMap.getPreferredSize());
}
}
});
displayMenu.add(menuItem);
}
public JScrollPane createMainMap() {
if (null == this.mainMap) {
// this.mainMap = new MapJPanel();
this.mainMap = new MapViewJComponentConcrete();
mainMapScrollPane1 = new JScrollPane();
mainMapScrollPane1.setViewportView(this.mainMap);
addMainMapAndOverviewMapMediatorIfNecessary();
}
return mainMapScrollPane1;
}
public JPanel createOverviewMap() {
if (null == this.overviewMap) {
// this.overviewMap = new OverviewMapJPanel();
this.overviewMap = new OverviewMapJComponent(r);
this.overviewMap.setup(new BlankMapRenderer(0.4F));
addMainMapAndOverviewMapMediatorIfNecessary();
}
return overviewMap;
// return new TestPanel();
}
private void addMainMapAndOverviewMapMediatorIfNecessary() {
if (this.mainMap != null && this.overviewMap != null
&& null == this.mediator) {
// Rectangle r = this.overviewMap.getMainMapVisibleRect();
this.mediator = new MainMapAndOverviewMapMediator(overviewMap,
mainMapScrollPane1.getViewport(), mainMap, r);
}
}
public JLabel createCashJLabel() {
return null;
}
public JLabel createDateJLabel() {
return null;
}
public JMenu createHelpMenu() {
return null;
}
public JTabbedPane createTrainsJTabPane() {
return null;
}
public JMenu createReportsMenu() {
// TODO Auto-generated method stub
return null;
}
}

/**
* An UntriedMoveReceiver that executes moves on the world object passed to its
* constructor.
*
* @author Luke
*
*/
public final class SimpleMoveReceiver implements UntriedMoveReceiver {
private final World w;
public SimpleMoveReceiver(World w) {
this.w = w;
if (null == w)
throw new NullPointerException();
}
public MoveStatus tryDoMove(Move move) {
return move.tryDoMove(w, Player.AUTHORITATIVE);
}
public void processMove(Move move) {
move.doMove(w, Player.AUTHORITATIVE);
}
public void processPreMove(PreMove pm) {
processMove(pm.generateMove(w));
}
}

/**
* <p>
* Used to test the logging configuration.
* </p>
* <p>
* Usage:<code> java -Djava.util.logging.config.file=logging.properties experimental.TestLogging</code>
* </p>
* <p>
* Make sure <code>logging.properties</code> is in the working directory.
* </p>
*
* @author Luke
*/
public class TestLogging {
public static void main(String[] args) {
Logger logger1 = Logger.getLogger(TestLogging.class.getName());
logger1.info("Logging properties file: "
+ System.getProperty("java.util.logging.config.file"));
logger1.severe("Hello severe logging");
logger1.warning("Hello warning logging");
logger1.info("Hello info logging");
logger1.fine("Hello fine logging");
logger1.finer("Hello finer logging");
logger1.finest("Hello finest logging");
}
}

/**
* Provides methods that render track pieces.
*
* @see experimental.TrackTilesGenerator
* @author Luke Lindsay
*
*/
public class TrackRenderer {
private final ImageManager imageManager = new ImageManagerImpl(
"/jfreerails/client/graphics/");
Color sleepersColor = new Color(118, 54, 36);
Color railsColor = new Color(118, 118, 118);
double sleeperLength = 6;
float sleeperWidth = 2f;
float targetSleeperGap = 2.5f;
float tileWidth = 30f;
float gauge = 3f;
BasicStroke rail = new BasicStroke(1f);
boolean doubleTrack = false;
float doubleTrackGap = 4f;
Image icon = null;
boolean tunnel = false;
void paintTrackConf(Graphics2D g2, TrackConfiguration conf) {
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
// Draw title
// String title = BinaryNumberFormatter.formatWithLowBitOnLeft(conf
// .get9bitTemplate(), 9);
// g.setColor(Color.BLACK);
// g.setFont(font);
//
// g.drawString(title, 10, 10);
Step[] directions = Step.getList();
List<CubicCurve2D.Double> sections = new ArrayList<CubicCurve2D.Double>();
int matches = 0;
for (int i = 0; i < directions.length - 2; i++) {
if (conf.contains(directions[i])) {
// System.out.println("\n"+directions[i]+" to ..");
int maxJ = Math.min(i + 7, directions.length);
for (int j = i + 2; j < maxJ; j++) {
// System.out.println(directions[j]);
if (conf.contains(directions[j])) {
Double toCurve = toCurve(directions[i], directions[j]);
if (doubleTrack) {
sections.add(createAdjacentCurve(toCurve,
doubleTrackGap, doubleTrackGap));
sections.add(createAdjacentCurve(toCurve,
-doubleTrackGap, -doubleTrackGap));
} else {
sections.add(toCurve);
}
matches++;
}
}
}
}
if (matches == 0) {
for (int i = 0; i < directions.length; i++) {
if (conf.contains(directions[i])) {
Double toCurve = toCurve(directions[i]);
if (doubleTrack) {
sections.add(createAdjacentCurve(toCurve,
doubleTrackGap, doubleTrackGap));
sections.add(createAdjacentCurve(toCurve,
-doubleTrackGap, -doubleTrackGap));
} else {
sections.add(toCurve);
}
}
}
}
paintTrack(g2, sections);
}
CubicCurve2D.Double toCurve(Step a) {
float halfTile = tileWidth / 2;
Point2D.Double start, end, one;
start = new Point2D.Double();
start.x = tileWidth + (halfTile * a.deltaX);
start.y = tileWidth + (halfTile * a.deltaY);
one = controlPoint(start);
end = new Point2D.Double(tileWidth, tileWidth);
CubicCurve2D.Double returnValue = new CubicCurve2D.Double();
returnValue.setCurve(start, one, one, end);
return returnValue;
}
CubicCurve2D.Double toCurve(Step a, Step b) {
float halfTile = tileWidth / 2;
Point2D.Double start, end, one, two;
start = new Point2D.Double();
start.x = tileWidth + (halfTile * a.deltaX);
start.y = tileWidth + (halfTile * a.deltaY);
one = controlPoint(start);
end = new Point2D.Double();
end.x = tileWidth + (halfTile * b.deltaX);
end.y = tileWidth + (halfTile * b.deltaY);
two = controlPoint(end);
CubicCurve2D.Double returnValue = new CubicCurve2D.Double();
returnValue.setCurve(start, one, two, end);
return returnValue;
}
void paintTrack(Graphics2D g, List<CubicCurve2D.Double> sections) {
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
if (!tunnel) {
// Draw sleepers
g.setColor(sleepersColor);
for (CubicCurve2D.Double section : sections) {
BasicStroke dashed = getStroke4Curve(section);
g.setStroke(dashed);
g.draw(section);
}
g.setColor(railsColor);
} else {
g.setColor(Color.BLACK);
}
// Draw rails
g.setStroke(rail);
for (CubicCurve2D.Double section : sections) {
float halfGauge = gauge / 2;
CubicCurve2D.Double rail1 = createAdjacentCurve(section, halfGauge,
halfGauge);
CubicCurve2D.Double rail2 = createAdjacentCurve(section,
-halfGauge, -halfGauge);
g.draw(rail1);
g.draw(rail2);
}
}
/**
* Generates the Stroke used to draw the sleepers for track section
* represented by the specified curve.
*/
public BasicStroke getStroke4Curve(CubicCurve2D.Double curve) {
PathIterator fpt = curve.getPathIterator(new AffineTransform(), 0.01);
double length = 0;
double[] coords = new double[6];
double x, y;
fpt.currentSegment(coords);
double lastX = coords[0];
double lastY = coords[1];
for (; !fpt.isDone(); fpt.next()) {
fpt.currentSegment(coords);
x = coords[0];
y = coords[1];
double dx = x - lastX;
double dy = y - lastY;
length += Math.sqrt(dx * dx + dy * dy);
lastX = x;
lastY = y;
}
float sleepers = (float) length / (targetSleeperGap + sleeperWidth);
float sleeperCount = (int) sleepers;
float sleeperGap = (float) length / sleeperCount - sleeperWidth;
float dash1[] = { sleeperWidth, sleeperGap };
float phase = sleeperWidth + (sleeperGap / 2);
return new BasicStroke((float) sleeperLength, BasicStroke.CAP_BUTT,
BasicStroke.JOIN_MITER, 10.0f, dash1, phase);
}
public static Line2D.Double createParallelLine(Line2D.Double line,
double shift) {
Line2D.Double returnValue = new Line2D.Double(line.getP1(), line
.getP2());
double distance = line.getP1().distance(line.getP2());
double dRatio = shift / distance;
double dx = (line.x1 - line.x2) * dRatio;
double dy = (line.y1 - line.y2) * dRatio;
returnValue.x1 -= dy;
returnValue.y1 += dx;
returnValue.x2 -= dy;
returnValue.y2 += dx;
return returnValue;
}
public static CubicCurve2D.Double createAdjacentCurve(
CubicCurve2D.Double c, double shift1, double shift2) {
Line2D.Double line1 = new Line2D.Double(c.getX1(), c.getY1(), c
.getCtrlX1(), c.getCtrlY1());
Line2D.Double line2 = new Line2D.Double(c.getX2(), c.getY2(), c
.getCtrlX2(), c.getCtrlY2());
line1 = createParallelLine(line1, shift1);
line2 = createParallelLine(line2, -shift2);
return new CubicCurve2D.Double(line1.x1, line1.y1, line1.x2, line1.y2,
line2.x2, line2.y2, line2.x1, line2.y1);
}
private Point2D.Double controlPoint(Point2D.Double from) {
double weight = 0.3;
double x = from.getX() * weight + tileWidth * (1 - weight);
double y = from.getY() * weight + tileWidth * (1 - weight);
return new Point2D.Double(x, y);
}
void setIcon(String typeName) {
try {
String relativeFileName = "icons" + File.separator + typeName
+ ".png";
relativeFileName = relativeFileName.replace(' ', '_');
Image im = imageManager.getImage(relativeFileName);
icon = im;
} catch (IOException e) {
e.printStackTrace();
throw new IllegalStateException(e);
}
}
}

/**
* Generates track graphic image files.
*
* @author Luke
*/
public class TrackTilesGenerator extends JPanel {
private static final long serialVersionUID = 3618982273966487859L;
public static void main(String[] args) {
JFrame frame = new JFrame();
JScrollPane scrollPane = new JScrollPane();
frame.add(scrollPane);
TrackTilesGenerator trackTilesGenerator = new TrackTilesGenerator();
trackTilesGenerator.setPreferredSize(trackTilesGenerator
.getSize4Panel());
scrollPane.setViewportView(trackTilesGenerator);
frame.setSize(500, 500);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
private final ImageManager imageManager = new ImageManagerImpl(
"/experimental/", "/experimental/");
private List<TrackRule> rules;
private TrackRenderer tr;
CubicCurve2D.Double[] track;
public TrackTilesGenerator() {
Point2D.Double start, end, one, two;
track = new CubicCurve2D.Double[3];
track[0] = new CubicCurve2D.Double();
start = new Point2D.Double(150, 300);
end = new Point2D.Double(450, 150);
one = controlPoint(start);
two = controlPoint(end);
track[0].setCurve(start, one, two, end);
track[1] = TrackRenderer.createAdjacentCurve(track[0], 0, 0);
track[2] = TrackRenderer.createAdjacentCurve(track[0], -60, -60);
tr = new TrackRenderer();
URL track_xml_url = OldWorldImpl.class
.getResource("/jfreerails/data/track_tiles.xml");
Track_TilesHandlerImpl trackSetFactory = new Track_TilesHandlerImpl(
track_xml_url);
rules = trackSetFactory.getRuleList();
generateTiles();
}
private Point2D.Double controlPoint(Point2D.Double from) {
double weight = 0.3;
double x = from.getX() * weight + 300 * (1 - weight);
double y = from.getY() * weight + 300 * (1 - weight);
return new Point2D.Double(x, y);
}
private void generateTiles() {
for (TrackRule rule : rules) {
TrackRule.TrackCategories category = rule.getCategory();
Image icon;
if (category.equals(TrackRule.TrackCategories.bridge)
|| category.equals(TrackRule.TrackCategories.station)) {
tr.setIcon(rule.getTypeName());
icon = tr.icon;
} else {
icon = null;
}
if (category.equals(TrackRule.TrackCategories.tunnel)) {
tr.tunnel = true;
} else {
tr.tunnel = false;
}
tr.doubleTrack = rule.isDouble();
for (int i = 0; i < 512; i++) {
if (rule.testTrackPieceLegality(i)) {
String fileName = TrackPieceRendererImpl.generateFilename(
i, rule.getTypeName());
TrackConfiguration conf = TrackConfiguration
.from9bitTemplate(i);
Image smallImage = imageManager.newBlankImage(60, 60);
Graphics2D g2 = (Graphics2D) smallImage.getGraphics();
tr.paintTrackConf(g2, conf);
// Draw icon. Used for bridges and stations.
if (null != icon) {
int x = 30 - icon.getWidth(null) / 2;
int y = 30 - icon.getHeight(null) / 2;
g2.drawImage(icon, x, y, null);
}
g2.dispose();
imageManager.setImage(fileName, smallImage);
}
}
}
try {
imageManager.writeAllImages();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private Dimension getSize4Panel() {
int height = 90 * rules.size();
int width = 0;
int lastWidth = 0;
for (TrackRule rule : rules) {
width = Math.max(width, lastWidth);
lastWidth = 0;
Iterator<TrackConfiguration> it = rule
.getLegalConfigurationsIterator();
while (it.hasNext()) {
lastWidth += 60;
}
}
return new Dimension(width, height);
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
for (TrackRule rule : rules) {
String typeName = rule.getTypeName();
typeName += rule.isDouble() ? " (Double) " : " (Single)";
g.drawString(typeName, 10, 10);
g.translate(0, 30);
Graphics2D g2 = (Graphics2D) g.create();
for (int i = 0; i < 512; i++) {
if (rule.testTrackPieceLegality(i)) {
String fileName = TrackPieceRendererImpl.generateFilename(
i, rule.getTypeName());
Image tile;
try {
tile = imageManager.getImage(fileName);
g2.drawImage(tile, 0, 0, null);
g2.translate(60, 0);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
g.translate(0, 60);
}
}
}

/**
* This class is a visual test for the train movement code.
*
* TODO: Update the trains position when necessary. Make the train stop at
* intervals, and slowly accelerate.
*
* @author Luke Lindsay
*
*/
public class TrainMotionExpt extends JComponent {
private static final long serialVersionUID = 3690191057862473264L;
private final World world;
private final FreerailsPrincipal principal;
private double finishTime = 0;
private long startTime;
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
// Shade tiles with track..
g.setColor(Color.GREEN);
for (int x = 0; x < world.getMapWidth(); x++) {
for (int y = 0; y < world.getMapHeight(); y++) {
FreerailsTile tile = (FreerailsTile) world.getTile(x, y);
if (tile.getTrackPiece().getTrackTypeID() != NullTrackType.NULL_TRACK_TYPE_RULE_NUMBER) {
int w = Step.TILE_DIAMETER;
int h = Step.TILE_DIAMETER;
g.drawRect(x * Step.TILE_DIAMETER, y * Step.TILE_DIAMETER,
w, h);
}
}
}
long l = System.currentTimeMillis() - startTime;
double ticks = (double) l / 1000;
while (ticks > finishTime) {
updateTrainPosition();
}
ActivityIterator ai = world.getActivities(principal, 0);
while (ai.getFinishTime() < ticks && ai.hasNext()) {
ai.nextActivity();
}
double t = Math.min(ticks, ai.getFinishTime());
t = t - ai.getStartTime();
TrainMotion motion = (TrainMotion) ai.getActivity();
TrainPositionOnMap pos = (TrainPositionOnMap) ai.getState(ticks);
PathOnTiles pathOT = motion.getPath();
Iterator<ImPoint> it = pathOT.tiles();
while (it.hasNext()) {
ImPoint tile = it.next();
int x = tile.x * Step.TILE_DIAMETER;
int y = tile.y * Step.TILE_DIAMETER;
int w = Step.TILE_DIAMETER;
int h = Step.TILE_DIAMETER;
g.setColor(Color.WHITE);
g.fillRect(x, y, w, h);
g.setColor(Color.DARK_GRAY);
g.drawRect(x, y, w, h);
}
pathOT = motion.getTiles(t);
it = pathOT.tiles();
while (it.hasNext()) {
ImPoint tile = it.next();
int x = tile.x * Step.TILE_DIAMETER;
int y = tile.y * Step.TILE_DIAMETER;
int w = Step.TILE_DIAMETER;
int h = Step.TILE_DIAMETER;
g.setColor(Color.LIGHT_GRAY);
g.fillRect(x, y, w, h);
g.setColor(Color.DARK_GRAY);
g.drawRect(x, y, w, h);
}
g.setColor(Color.BLACK);
IntLine line = new IntLine();
FreerailsPathIterator path = pos.path();
while (path.hasNext()) {
path.nextSegment(line);
g.drawLine(line.x1, line.y1, line.x2, line.y2);
}
int speed = (int) Math.round(pos.getSpeed());
g.drawString("Speed: " + speed, 260, 60);
}
private void updateTrainPosition() {
Random rand = new Random(System.currentTimeMillis());
MoveTrainPreMove moveTrain = new MoveTrainPreMove(0, principal);
Move m;
if (rand.nextInt(10) == 0) {
m = moveTrain.stopTrain(world);
} else {
m = moveTrain.generateMove(world);
}
MoveStatus ms = m.doMove(world, principal);
if (!ms.ok)
throw new IllegalStateException(ms.message);
ActivityIterator ai = world.getActivities(principal, 0);
while (ai.hasNext()) {
ai.nextActivity();
finishTime = ai.getFinishTime();
}
}
public TrainMotionExpt() {
world = MapFixtureFactory2.getCopy();
MoveExecutor me = new SimpleMoveExecutor(world, 0);
principal = me.getPrincipal();
ModelRoot mr = new ModelRootImpl();
TrackMoveProducer producer = new TrackMoveProducer(me, world, mr);
Step[] trackPath = { EAST, SOUTH_EAST, SOUTH, SOUTH_WEST, WEST,
NORTH_WEST, NORTH, NORTH_EAST };
ImPoint from = new ImPoint(5, 5);
MoveStatus ms = producer.buildTrack(from, trackPath);
if (!ms.ok)
throw new IllegalStateException(ms.message);
TrainOrdersModel[] orders = {};
ImmutableSchedule is = new ImmutableSchedule(orders, -1, false);
AddTrainPreMove addTrain = new AddTrainPreMove(0, new ImInts(), from,
principal, is);
Move m = addTrain.generateMove(world);
ms = m.doMove(world, principal);
if (!ms.ok)
throw new IllegalStateException(ms.message);
startTime = System.currentTimeMillis();
}
public static void main(String[] args) {
System.setProperty("SHOWFPS", "true");
JFrame f = new JFrame();
f.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
f.getContentPane().add(new TrainMotionExpt());
ScreenHandler screenHandler = new ScreenHandler(f,
ScreenHandler.WINDOWED_MODE);
screenHandler.apply();
GameLoop gameLoop = new GameLoop(screenHandler);
Thread t = new Thread(gameLoop);
t.start();
}
}

/**
* This class does nothing and is only here so that javadoc gets generated
* correctly.
*
* @author Luke
*
*/
public class JavaDocPlaceholder {
}

/**
* Provides a mapping from a set of ButtonModels or a ComboBoxModel to a set of
* Actions. To use with a set of buttons, call elements() to obtain the set of
* ButtonModels to apply to the buttons, and add each button in the enumeration
* to a ButtonGroup. Listeners should listen for changes to the model and not to
* any events from UI components, although UI components may call setAction() in
* order to receive property change updates and to set icons etc.
*
* @author Rob
*/
public class ActionAdapter extends DefaultComboBoxModel {
private static final long serialVersionUID = 3546920294666351415L;
/**
* The set of actions which each button / menu item correspond to.
*/
private final Action[] actions;
private boolean initialised = false;
private boolean performActionOnSetSelectedItem = true;
/**
* The set of MappedButtonModels corresponding to the actions.
*/
private final Vector<MappedButtonModel> buttonModels;
/**
* An array of the actions to be used. The ComboBoxModel objects are taken
* from the NAME property of the Action. The ButtonModel icons are obtained
* from the SMALL_ICON property.
*/
public ActionAdapter(Action[] actions) {
super();
this.actions = actions;
buttonModels = new Vector<MappedButtonModel>();
for (int i = 0; i < actions.length; i++) {
buttonModels.add(new MappedButtonModel(actions[i]));
addElement(actions[i].getValue(Action.NAME));
}
initialised = true;
}
/**
* @param actions
* An array of the actions to be used. The ComboBoxModel objects
* are taken from the NAME property of the Action. The
* ButtonModel icons are obtained from the SMALL_ICON property.
* @param selected
* Index of the default selected action.
*/
public ActionAdapter(Action[] actions, int selected) {
this(actions);
for (int i = 0; i < buttonModels.size(); i++) {
MappedButtonModel bm = buttonModels.get(i);
bm.setSelected(i == selected);
}
}
/**
* @return an enumeration of Action
*/
public Enumeration<Action> getActions() {
return new Enumeration<Action>() {
private int i = 0;
public boolean hasMoreElements() {
return (i < actions.length);
}
public Action nextElement() {
return actions[i++];
}
};
}
/**
* @return an enumeration of MappedButtonModel
*/
public Enumeration<MappedButtonModel> getButtonModels() {
return buttonModels.elements();
}
/**
* @param item
* The NAME of the Action selected
*/
@Override
public void setSelectedItem(Object item) {
// only set the item if not already selected
if ((item != null) && item.equals(getSelectedItem())) {
return;
}
super.setSelectedItem(item);
// stop addElement from triggering actions
if (!initialised) {
return;
}
for (int i = 0; i < buttonModels.size(); i++) {
MappedButtonModel bm = buttonModels.get(i);
if (bm.actionName.equals(item)) {
bm.setSelected(true);
}
}
if (performActionOnSetSelectedItem) {
for (int i = 0; i < actions.length; i++) {
if (actions[i].getValue(Action.NAME).equals(item)) {
actions[i].actionPerformed(new ActionEvent(this,
ActionEvent.ACTION_PERFORMED, (String) actions[i]
.getValue(Action.ACTION_COMMAND_KEY)));
}
}
}
}
public class MappedButtonModel extends JToggleButton.ToggleButtonModel
implements PropertyChangeListener {
private static final long serialVersionUID = 3834589889856353845L;
/**
* The NAME of the Action to which this ButtonModel is mapped.
*/
public final String actionName;
public MappedButtonModel(Action action) {
actionName = (String) action.getValue(Action.NAME);
action.addPropertyChangeListener(this);
setEnabled(action.isEnabled());
}
@Override
public void setSelected(boolean b) {
if (isSelected() != b) {
super.setSelected(b);
if (b) {
ActionAdapter.this.setSelectedItem(actionName);
}
}
}
public void propertyChange(PropertyChangeEvent e) {
setEnabled(((Action) e.getSource()).isEnabled());
}
}
public void setPerformActionOnSetSelectedItem(
boolean performActionOnSetSelectedItem) {
this.performActionOnSetSelectedItem = performActionOnSetSelectedItem;
}
}

/**
* Used to generate filenames for track and terrain images.
*
* @author Luke
*/
public class BinaryNumberFormatter {
public static String format(int i, int bits) {
int maxValue = 1 << (bits);
if (i < 0) {
throw new IllegalArgumentException(
"i must be greater than 0. It was " + i);
}
if (i >= maxValue) {
throw new IllegalArgumentException("i must be less than "
+ maxValue + ". It was " + i);
}
String s = Integer.toString(i + maxValue, 2);
String number = s.substring(1);
return number;
}
public static String formatWithLowBitOnLeft(int i, int bits) {
StringBuffer buff = new StringBuffer(format(i, bits));
buff.reverse();
return buff.toString();
}
}

/**
* This interface defines methods for loading and saving images, and producing
* scaled images whose quality may be controlled.
*
* @author Luke
*
*/
public interface ImageManager {
Image newBlankImage(int height, int width);
void setPathToReadFrom(String s);
void setPathToWriteTo(String s);
Image getImage(String relativeFilename) throws IOException;
boolean contains(String relativeFilename);
void setImage(String relativeFilename, Image i);
void writeImage(String relativeFilename) throws IOException;
void writeAllImages() throws IOException;
Image getScaledImage(String relativeFilename, int height)
throws IOException;
}

/**
* Implementation of ImageManager that returns images that are compatible with
* the current graphics configuration and whose transparency is set to
* TRANSLUCENT, the scaled images it returns are rendered with renderingHints
* set for quality.
*
* @author Luke
*
*/
public class ImageManagerImpl implements ImageManager {
/**
* Matches anying but a string beginning with a "/"*. The reason for this
* check is that relative filenames such as "/cursor/removetrack.png" work
* from with files but not from within jars, which lets bugs slip in.
*/
private static final String A_REGEX = "^[^///].*";
private static final Logger logger = Logger
.getLogger(ImageManagerImpl.class.getName());
private static final Pattern pattern = Pattern.compile(A_REGEX);
public static boolean isValid(String s) {
Matcher m = pattern.matcher(s);
return m.matches();
}
private final GraphicsConfiguration defaultConfiguration = GraphicsEnvironment
.getLocalGraphicsEnvironment().getDefaultScreenDevice()
.getDefaultConfiguration();
private final HashMap<String, Image> imageHashMap = new HashMap<String, Image>();
private String pathToReadFrom;
private String pathToWriteTo;
private final RenderingHints renderingHints;
private final HashMap<String, Image> scaledImagesHashMap = new HashMap<String, Image>();
public ImageManagerImpl(String readpath) {
this(readpath, null);
}
public ImageManagerImpl(String readpath, String writePath) {
pathToReadFrom = readpath;
pathToWriteTo = writePath;
// Attempt to increase quality..
renderingHints = new RenderingHints(
RenderingHints.KEY_ALPHA_INTERPOLATION,
RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
renderingHints.put(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
renderingHints.put(RenderingHints.KEY_INTERPOLATION,
RenderingHints.VALUE_INTERPOLATION_BICUBIC);
}
public boolean contains(String relativeFilename) {
relativeFilename = relativeFilename.replace(' ', '_');
if (imageHashMap.containsKey(relativeFilename)) {
return true;
}
File f = new File(pathToWriteTo + File.separator + relativeFilename);
if (f.isFile()) {
return true;
}
return false;
}
public Image getImage(String relativeFilename) throws IOException {
relativeFilename = relativeFilename.replace(' ', '_');
if (!isValid(relativeFilename))
throw new IllegalArgumentException(relativeFilename
+ " must match " + A_REGEX);
if (imageHashMap.containsKey(relativeFilename)) {
return imageHashMap.get(relativeFilename);
}
// File f = new File(pathToReadFrom+File.separator+relativeFilename);
String read = pathToReadFrom + relativeFilename;
read = read.replace(File.separatorChar, '/');
URL url = ImageManagerImpl.class.getResource(read);
if (null == url) {
throw new IOException("Couldn't find: " + read);
}
Image tempImage = ImageIO.read(url);
if (null == tempImage) {
throw new IOException("Couldn't find: " + read);
}
Image compatibleImage = defaultConfiguration.createCompatibleImage(
tempImage.getWidth(null), tempImage.getHeight(null),
Transparency.TRANSLUCENT);
Graphics g = compatibleImage.getGraphics();
g.drawImage(tempImage, 0, 0, null);
imageHashMap.put(relativeFilename, compatibleImage);
return compatibleImage;
}
/**
* Returns the specified image scaled so that its height is equal to the
* specified height.
*/
public Image getScaledImage(String relativeFilename, int height)
throws IOException {
relativeFilename = relativeFilename.replace(' ', '_');
if (!isValid(relativeFilename))
throw new IllegalArgumentException(relativeFilename
+ " must match " + A_REGEX);
String hashKey = relativeFilename + height;
if (this.scaledImagesHashMap.containsKey(hashKey)) {
return scaledImagesHashMap.get(hashKey);
}
Image i = getImage(relativeFilename);
if (i.getHeight(null) == height) {
return i;
}
int width = (i.getWidth(null) * height) / i.getHeight(null);
Image compatibleImage = newBlankImage(height, width);
Graphics2D g = (Graphics2D) compatibleImage.getGraphics();
g.setRenderingHints(this.renderingHints);
g.drawImage(i, 0, 0, width, height, null);
scaledImagesHashMap.put(hashKey, compatibleImage);
return compatibleImage;
}
public Image newBlankImage(int height, int width) {
Image compatibleImage = defaultConfiguration.createCompatibleImage(
width, height, Transparency.TRANSLUCENT);
return compatibleImage;
}
public void setImage(String relativeFilename, Image i) {
relativeFilename = relativeFilename.replace(' ', '_');
if (i == null) {
throw new NullPointerException(relativeFilename);
}
imageHashMap.put(relativeFilename, i);
}
public void setPathToReadFrom(String s) {
pathToReadFrom = s;
}
public void setPathToWriteTo(String s) {
pathToWriteTo = s;
}
public void writeAllImages() throws IOException {
for (String s : imageHashMap.keySet()) {
writeImage(s);
}
}
public void writeImage(String relativeFilename) throws IOException {
if (null == pathToWriteTo)
throw new NullPointerException("null == pathToWriteTo");
relativeFilename = relativeFilename.replace(' ', '_');
File f = new File(pathToWriteTo + File.separator + relativeFilename);
if (imageHashMap.containsKey(relativeFilename)) {
RenderedImage i = (RenderedImage) imageHashMap
.get(relativeFilename);
String pathName = f.getPath();
File path = new File(pathName);
path.mkdirs();
ImageIO.write(i, "png", f);
logger.info("Writing " + f);
} else {
throw new NoSuchElementException(relativeFilename);
}
}
}

/**
* Provides access to the World object and other data that is shared by GUI
* components (for instance the cursor's position).
*
* @author Luke
* @author Rob
*/
public final class ModelRootImpl implements ModelRoot, ServerCommandReceiver {
public boolean hasBeenSetup = false;
private MoveChainFork moveFork = new MoveChainFork();
private UntriedMoveReceiver moveReceiver = new UntriedMoveReceiver() {
public void processMove(Move Move) {
}
public void processPreMove(PreMove pm) {
}
public MoveStatus tryDoMove(Move move) {
return MoveStatus.moveFailed("No move receiver set on model root!");
}
};
private FreerailsPrincipal playerPrincipal;
private final HashMap<Property, Object> properties = new HashMap<Property, Object>();
private ServerCommandReceiver serverCommandReceiver;
private ReadOnlyWorld world;
private final ArrayList<ModelRootListener> listeners = new ArrayList<ModelRootListener>();
public ModelRootImpl() {
properties.put(Property.CURSOR_POSITION, new ImPoint());
properties.put(Property.SHOW_STATION_NAMES, Boolean.TRUE);
properties.put(Property.SHOW_CARGO_AT_STATIONS, Boolean.TRUE);
properties.put(Property.SHOW_STATION_BORDERS, Boolean.TRUE);
properties.put(Property.CURSOR_MODE, Value.BUILD_TRACK_CURSOR_MODE);
properties.put(Property.PREVIOUS_CURSOR_MODE,
Value.BUILD_TRACK_CURSOR_MODE);
properties.put(Property.SERVER, "server details not set!");
properties.put(Property.PLAY_SOUNDS, Boolean.TRUE);
properties.put(Property.IGNORE_KEY_EVENTS, Boolean.FALSE);
properties.put(Property.TIME, new Double(0));
properties.put(Property.TRACK_BUILDER_MODE,
TrackMoveProducer.BuildMode.BUILD_TRACK);
properties.put(Property.SAVED_GAMES_LIST, new ImStringList());
addPropertyChangeListener(SoundManager.getSoundManager());
}
public void addCompleteMoveReceiver(MoveReceiver l) {
this.moveFork.addCompleteMoveReceiver(l);
}
public void addListListener(WorldListListener listener) {
this.moveFork.addListListener(listener);
}
public void addMapListener(WorldMapListener l) {
this.moveFork.addMapListener(l);
}
public void addPropertyChangeListener(ModelRootListener l) {
listeners.add(l);
}
public void addSplitMoveReceiver(MoveReceiver l) {
this.moveFork.addSplitMoveReceiver(l);
}
public MoveStatus doMove(Move m) {
MoveStatus ms = this.moveReceiver.tryDoMove(m);
this.moveReceiver.processMove(m);
return ms;
}
public MoveStatus doPreMove(PreMove pm) {
Move m = pm.generateMove(world);
MoveStatus ms = moveReceiver.tryDoMove(m);
moveReceiver.processPreMove(pm);
return ms;
}
public FreerailsPrincipal getPrincipal() {
if (null == playerPrincipal) {
throw new NullPointerException();
}
return playerPrincipal;
}
public Object getProperty(Property p) {
return properties.get(p);
}
public ReadOnlyWorld getWorld() {
return world;
}
public void sendCommand(Message2Server c) {
if (null != serverCommandReceiver) {
serverCommandReceiver.sendCommand(c);
} else {
System.err.println(c.toString());
}
}
public void setMoveFork(MoveChainFork moveFork) {
this.moveFork = moveFork;
}
public void setMoveReceiver(UntriedMoveReceiver moveReceiver) {
this.moveReceiver = moveReceiver;
}
public void setProperty(Property p, Object newValue) {
Object oldValue = properties.get(p);
properties.put(p, newValue);
for (ModelRootListener listener : listeners) {
listener.propertyChange(p, oldValue, newValue);
}
}
public void setServerCommandReceiver(
ServerCommandReceiver serverCommandReceiver) {
this.serverCommandReceiver = serverCommandReceiver;
}
/**
* Updates the ModelRoot with those properties which are dependent upon the
* world model. Call this when the world model is changed (e.g. new map is
* loaded)
*/
public void setup(ReadOnlyWorld world, FreerailsPrincipal p) {
this.world = world;
assert p != null;
assert world.isPlayer(p);
playerPrincipal = p;
if (null == world) {
throw new NullPointerException();
}
BuildTrackStrategy bts = BuildTrackStrategy.getDefault(world);
setProperty(ModelRoot.Property.BUILD_TRACK_STRATEGY, bts);
hasBeenSetup = true;
}
public MoveStatus tryDoMove(Move m) {
return this.moveReceiver.tryDoMove(m);
}
public boolean is(ModelRoot.Property p, Object value) {
return getProperty(p).equals(value);
}
}

/**
* @author Luke
*
*/
public interface ModelRootListener {
void propertyChange(ModelRoot.Property p, Object oldValue, Object newValue);
}

/**
* A transparent JPanel that catches key presses and mouse clicks.
*
* @author lindsal8
*
*/
public class MyGlassPanel extends javax.swing.JPanel {
private static final long serialVersionUID = 3976735856986239795L;
public MyGlassPanel() {
initComponents();
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the FormEditor.
*/
private void initComponents() { // GEN-BEGIN:initComponents
contentPanel = new javax.swing.JPanel();
setLayout(new java.awt.GridBagLayout());
java.awt.GridBagConstraints gridBagConstraints1;
setOpaque(false);
addKeyListener(new java.awt.event.KeyAdapter() {
@Override
public void keyPressed(java.awt.event.KeyEvent evt) {
formKeyPressed(evt);
}
});
addMouseListener(new java.awt.event.MouseAdapter() {
@Override
public void mousePressed(java.awt.event.MouseEvent evt) {
formMousePressed(evt);
}
});
addMouseMotionListener(new java.awt.event.MouseMotionAdapter() {
@Override
public void mouseMoved(java.awt.event.MouseEvent evt) {
formMouseMoved(evt);
}
});
contentPanel.setPreferredSize(new java.awt.Dimension(60, 40));
contentPanel.setMinimumSize(new java.awt.Dimension(60, 40));
contentPanel.setBackground(java.awt.Color.red);
contentPanel.setMaximumSize(new java.awt.Dimension(60, 40));
gridBagConstraints1 = new java.awt.GridBagConstraints();
gridBagConstraints1.gridx = 2;
gridBagConstraints1.gridy = 1;
add(contentPanel, gridBagConstraints1);
}
// GEN-END:initComponents
private void formMouseMoved(java.awt.event.MouseEvent evt) { // GEN-FIRST:event_formMouseMoved
// Add your handling code here:
}
// GEN-LAST:event_formMouseMoved
private void formMousePressed(java.awt.event.MouseEvent evt) { // GEN-FIRST:event_formMousePressed
// Add your handling code here:
}
// GEN-LAST:event_formMousePressed
private void formKeyPressed(java.awt.event.KeyEvent evt) { // GEN-FIRST:event_formKeyPressed
// Add your handling code here:
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JComponent contentPanel;
// End of variables declaration//GEN-END:variables
}

/**
* Paints a layer of the map view.
*
* @author Luke
*/
public interface Painter {
void paint(Graphics2D g);
}

/**
* This RepaintManager is intended to be used when we are using active rendering
* to paint a top level component. Repaint requests for components whose
* TopLevelAncestor is the component being actively rendered in the game loop
* are ignored; repaint requests for components whose TopLevelAncestor is
* <strong>not</strong> the component being actively rendered in the game loop
* are processed normally. This behaviour is needed because when menus extend
* outside the bounds of their parent window, they have a different top level
* component to the parent window, so are not painted when paintComponents is
* called from the game loop.
*
* @author Luke
*
*/
public final class RepaintManagerForActiveRendering extends RepaintManager {
/** The JFrame(s) that are being actively rendered in the game loop(s). */
private static final HashSet<JFrame> activelyRenderedComponents = new HashSet<JFrame>();
private static final RepaintManagerForActiveRendering instance = new RepaintManagerForActiveRendering();
private static long numRepaintRequests = 0;
public static void setAsCurrentManager() {
RepaintManager.setCurrentManager(instance);
}
private RepaintManagerForActiveRendering() {
}
@Override
public synchronized void addDirtyRegion(JComponent c, int x, int y, int w,
int h) {
if (hasDifferentAncestor(c)) {
super.addDirtyRegion(c, x, y, w, h);
} else {
numRepaintRequests++;
}
}
public static synchronized void addJFrame(JFrame f) {
activelyRenderedComponents.add(f);
}
@Override
public synchronized void addInvalidComponent(JComponent invalidComponent) {
if (hasDifferentAncestor(invalidComponent)) {
super.addInvalidComponent(invalidComponent);
} else {
numRepaintRequests++;
}
}
@Override
public void markCompletelyClean(JComponent aComponent) {
if (hasDifferentAncestor(aComponent)) {
super.markCompletelyClean(aComponent);
} else {
numRepaintRequests++;
}
}
@Override
public void markCompletelyDirty(JComponent aComponent) {
if (hasDifferentAncestor(aComponent)) {
super.markCompletelyDirty(aComponent);
} else {
numRepaintRequests++;
}
}
private boolean hasDifferentAncestor(JComponent aComponent) {
Container topLevelAncestor = aComponent.getTopLevelAncestor();
if (null == topLevelAncestor
|| activelyRenderedComponents.contains(topLevelAncestor)) {
return false;
}
return true;
}
public static long getNumRepaintRequests() {
return numRepaintRequests;
}
}

/**
* This class is responsible for loading and playing sounds. Samples are read
* into a byte arrays so that they don't need to be loaded from disk each time
* they are played.
*
* @author Luke
*
*/
public class SoundManager implements ModelRootListener, LineListener {
/**
* Stores the audio data and properties of a sample.
*
*/
private static class Sample {
byte[] audio;
AudioFormat format;
DataLine.Info info;
int size;
}
private static final Logger logger = Logger.getLogger(SoundManager.class
.getName());
private static final SoundManager soundManager = new SoundManager();
public static SoundManager getSoundManager() {
return soundManager;
}
public static void main(String[] args) {
SoundManager soundPlayer = getSoundManager();
for (int i = 0; i < 100; i++) {
soundPlayer.playSound("/jfreerails/client/sounds/cash.wav", 10);
try {
Thread.sleep(40);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private int maxLines;
private Mixer mixer;
private boolean playSounds = true;
private HashMap<String, Sample> samples = new HashMap<String, Sample>();
private final LinkedList<Clip> voices = new LinkedList<Clip>();
private SoundManager() {
AudioFormat format2 = new AudioFormat(8000f, 16, 1, true, false);
DataLine.Info info2 = new DataLine.Info(Clip.class, format2);
for (Mixer.Info mo : AudioSystem.getMixerInfo()) {
mixer = AudioSystem.getMixer(mo);
maxLines = mixer.getMaxLines(info2);
if (maxLines == AudioSystem.NOT_SPECIFIED){
maxLines = 100;
}
if (maxLines >= 32)
break; // Java Sound Audio Engine, version 1.0 satisfies this.
}
logger.fine("Sound Mixer: " + mixer.getMixerInfo() + "(" + maxLines
+ " voices).");
}
public void addClip(String s) throws IOException,
UnsupportedAudioFileException, LineUnavailableException {
if (samples.containsKey(s)) {
return;
}
URL url = getClass().getResource(s);
AudioInputStream audioInputStream = AudioSystem
.getAudioInputStream(loadStream(url.openStream()));
Sample sample = new Sample();
sample.format = audioInputStream.getFormat();
sample.size = (int) (sample.format.getFrameSize() * audioInputStream
.getFrameLength());
sample.audio = new byte[sample.size];
sample.info = new DataLine.Info(Clip.class, sample.format, sample.size);
audioInputStream.read(sample.audio, 0, sample.size);
samples.put(s, sample);
}
private ByteArrayInputStream loadStream(InputStream inputstream)
throws IOException {
ByteArrayOutputStream bytearrayoutputstream = new ByteArrayOutputStream();
byte[] data = new byte[1024];
for (int i = inputstream.read(data); i != -1; i = inputstream
.read(data)) {
bytearrayoutputstream.write(data, 0, i);
}
inputstream.close();
bytearrayoutputstream.close();
data = bytearrayoutputstream.toByteArray();
return new ByteArrayInputStream(data);
}
public void playSound(String s, int loops) {
if (playSounds) {
try {
if (!samples.containsKey(s)) {
addClip(s);
}
Sample sample = samples.get(s);
Clip clip;
if (voices.size() < maxLines) {
clip = (Clip) mixer.getLine(sample.info);
} else {
clip = voices.removeFirst();
clip.stop();
clip.flush();
clip.close();
}
clip.addLineListener(this);
clip.open(sample.format, sample.audio, 0, sample.size);
clip.loop(loops);
voices.add(clip);
} catch (LineUnavailableException e) {
logger.warning(e.getMessage());
} catch (Exception e) {
e.printStackTrace();
}
}
}
public void propertyChange(ModelRoot.Property p, Object before, Object after) {
if (p.equals(ModelRoot.Property.PLAY_SOUNDS)) {
Boolean b = (Boolean) after;
playSounds = b.booleanValue();
}
}
public void update(LineEvent event) {
// TODO free up resources when we have finished playing a clip.
}
}

/**
* This class encapsulates the visible properties of a tile.
*
* @author Luke Lindsay
*/
public abstract class AbstractTileRenderer implements TileRenderer {
private final int[] typeNumbers;
private Image[] tileIcons;
private final TerrainType tileModel;
AbstractTileRenderer(TerrainType t, int[] rgbValues) {
tileModel = t;
this.typeNumbers = rgbValues;
if (null == t) {
throw new NullPointerException();
}
if (null == rgbValues) {
throw new NullPointerException();
}
}
public void renderTile(java.awt.Graphics g, int screenX, int screenY,
int mapX, int mapY, ReadOnlyWorld w) {
Image icon = this.getIcon(mapX, mapY, w);
if (null != icon) {
g.drawImage(icon, screenX, screenY, null);
}
}
public Image getDefaultIcon() {
return getTileIcons()[0];
}
String getTerrainType() {
return tileModel.getTerrainTypeName();
}
/**
* Returns an icon for the tile at x,y, which may depend on the terrain
* types of of the surrounding tiles.
*/
Image getIcon(int x, int y, ReadOnlyWorld w) {
int tile = selectTileIcon(x, y, w);
if (getTileIcons()[tile] != null) {
return getTileIcons()[tile];
}
throw new NullPointerException("Error in TileView.getIcon: icon no. "
+ tile + "==null");
}
int selectTileIcon(int x, int y, ReadOnlyWorld w) {
return 0;
}
int checkTile(int x, int y, ReadOnlyWorld w) {
int match = 0;
if (((x < w.getMapWidth()) && (x >= 0)) && (y < w.getMapHeight())
&& (y >= 0)) {
for (int i = 0; i < typeNumbers.length; i++) {
TerrainTile tt = (TerrainTile) w.getTile(x, y);
if (tt.getTerrainTypeID() == typeNumbers[i]) {
match = 1;
// A match
}
}
} else {
match = 1; // A match
/*
* If the tile we are checking is off the map, let it be a match.
* This stops coast appearing where the ocean meets the map edge.
*/
}
return match;
}
abstract public void dumpImages(ImageManager imageManager);
String generateRelativeFileName(int i) {
return "terrain" + File.separator + this.getTerrainType() + "_"
+ generateFileNameNumber(i) + ".png";
}
protected abstract String generateFileNameNumber(int i);
void setTileIcons(Image[] tileIcons) {
this.tileIcons = tileIcons;
}
Image[] getTileIcons() {
return tileIcons;
}
}

/**
* Used for testing the Map view components without setting up any map data.
*
* @author Luke
*/
public class BlankMapRenderer implements MapRenderer {
private final float scale;
public BlankMapRenderer(float s) {
scale = s;
}
public float getScale() {
return scale;
}
public Dimension getMapSizeInPixels() {
int height = (int) (400 * scale);
int width = (int) (400 * scale);
return new Dimension(height, width);
}
public void paintTile(Graphics g, int tileX, int tileY) {
paintRect(g, null);
}
public void refreshTile(int x, int y) {
}
public void paintRect(Graphics g, Rectangle visibleRect) {
g.setColor(Color.darkGray);
g.fillRect(0, 0, (int) (scale * 400), (int) (scale * 400));
g.setColor(Color.blue);
int x = (int) (100 * scale);
int y = (int) (100 * scale);
int height = (int) (200 * scale);
int width = (int) (200 * scale);
g.fillRect(x, y, height, width);
}
public void refreshAll() {
// do nothing
}
}

/**
* This abstract class stores a buffer of the background of the current visible
* rectangle of the map. Code that is independent of how tiles are represented,
* e.g. whether they are square or isometric, should go here.
*
* @author Luke Lindsay 06 October 2001
* @version 1.0
*
*/
public abstract class BufferedTiledBackgroundRenderer implements
MapLayerRenderer {
/**
* This is used to create images that are compatible with the default
* graphics configuration. Such images can be drawn to the screen quickly
* since no conversion is needed.
*/
private final GraphicsConfiguration defaultConfig = GraphicsEnvironment
.getLocalGraphicsEnvironment().getDefaultScreenDevice()
.getDefaultConfiguration();
/**
* Used to draw on the backbuffer.
*/
Graphics bg;
/**
* Used to draw on the backbuffer. It is translated so that to its users, it
* appears they are drawing on the actual map, not a buffered region of the
* map.
*
* translatedBg equals bg.translate(-bufferRect.x , -bufferRect.y);
*/
private Graphics translatedBg;
/**
* The bounds and location of the map region that is stored in the offscreen
* Image backgroundBuffer.
*/
final Rectangle bufferRect = new Rectangle();
/**
* An offscreen image storing the background of a region of the map.
*/
VolatileImage backgroundBuffer;
/**
* Updates the backbuffer as necessary, then draws it on to the Graphics
* object passed.
*
* @param outputGraphics
* Once it has been updated, the backbuffer is drawn onto this
* Graphics object.
* @param newVisibleRectangle
* The region of the map that the backbuffer must be updated to
* display.
*/
public void paintRect(Graphics outputGraphics,
Rectangle newVisibleRectangle) {
do {
/*
* If this is the first call to the paint method or the component
* has just been resized, we need to create a new backgroundBuffer.
*/
if ((backgroundBuffer == null)
|| (newVisibleRectangle.height != bufferRect.height)
|| (newVisibleRectangle.width != bufferRect.width)) {
setbackgroundBuffer(newVisibleRectangle.width,
newVisibleRectangle.height);
}
// Test if image is lost and restore it.
int valCode = backgroundBuffer.validate(defaultConfig);
if (valCode == VolatileImage.IMAGE_INCOMPATIBLE) {
setbackgroundBuffer(newVisibleRectangle.width,
newVisibleRectangle.height);
} else if (valCode == VolatileImage.IMAGE_RESTORED) {
resetGraphics();
this.refreshBackground();
}
/*
* Has the VisibleRectangle moved since the last paint?
*/
if ((bufferRect.x != newVisibleRectangle.x)
|| (bufferRect.y != newVisibleRectangle.y)) {
int dx = bufferRect.x - newVisibleRectangle.x;
int dy = bufferRect.y - newVisibleRectangle.y;
scrollbackgroundBuffer(dx, dy);
bufferRect.setBounds(newVisibleRectangle);
}
if ((bufferRect.width != newVisibleRectangle.width)
&& (bufferRect.height != newVisibleRectangle.height)) {
paintBufferRectangle(newVisibleRectangle.x - bufferRect.x,
newVisibleRectangle.y - bufferRect.y,
newVisibleRectangle.width,
newVisibleRectangle.height);
}
outputGraphics.drawImage(backgroundBuffer,
newVisibleRectangle.x, newVisibleRectangle.y, null);
bufferRect.setBounds(newVisibleRectangle);
} while (backgroundBuffer.contentsLost());
}
private void refreshBackground() {
paintBufferRectangle(0, 0, bufferRect.width, bufferRect.height);
}
public void refreshAll() {
refreshBackground();
}
private void setbackgroundBuffer(int w, int h) {
// Releases VRAM used by backgroundBuffer.
if (backgroundBuffer != null) {
backgroundBuffer.flush();
}
// Create new backgroundBuffer.
backgroundBuffer = defaultConfig.createCompatibleVolatileImage(w, h);
bufferRect.height = backgroundBuffer.getHeight(null);
bufferRect.width = backgroundBuffer.getWidth(null);
resetGraphics();
bg.clearRect(0, 0, w, h);
refreshBackground();
}
/** When the VolatileImage is created or restored, we need to (re)create the
Graphics objects.
*/
private void resetGraphics() {
if (bg != null) {
bg.dispose();
}
bg = backgroundBuffer.getGraphics();
if (translatedBg != null) {
translatedBg.dispose();
}
translatedBg = bg.create();
translatedBg.translate(-bufferRect.x, -bufferRect.y);
}
protected abstract void paintBufferRectangle(int x, int y, int width,
int height);
private void scrollbackgroundBuffer(int dx, int dy) {
int copyWidth = bufferRect.width;
int copyHeight = bufferRect.height;
int copySourceX = 0;
int copySourceY = 0;
if (dx > 0) {
copyWidth -= dx;
} else {
copyWidth += dx;
copySourceX = -dx;
}
if (dy > 0) {
copyHeight -= dy;
} else {
copyHeight += dy;
copySourceY = -dy;
}
bg.copyArea(copySourceX, copySourceY, copyWidth, copyHeight, dx, dy);
bufferRect.x -= dx;
bufferRect.y -= dy;
// paint exposed areas
if (dx != 0) {
if (dx > 0) {
bg.setClip(0, 0, dx, bufferRect.height);
bg.clearRect(0, 0, dx, bufferRect.height);
paintBufferRectangle(0, 0, dx, bufferRect.height);
} else {
bg.setClip(bufferRect.width + dx, 0, -dx, bufferRect.height);
bg.clearRect(bufferRect.width + dx, 0, -dx, bufferRect.height);
paintBufferRectangle(bufferRect.width + dx, 0, -dx,
bufferRect.height);
}
}
if (dy != 0) {
if (dy > 0) {
bg.setClip(0, 0, bufferRect.width, dy);
bg.clearRect(0, 0, bufferRect.width, dy);
paintBufferRectangle(0, 0, bufferRect.width, dy);
} else {
bg.setClip(0, bufferRect.height + dy, bufferRect.width, -dy);
bg.clearRect(0, bufferRect.height + dy, bufferRect.width, -dy);
paintBufferRectangle(0, bufferRect.height + dy,
bufferRect.width, -dy);
}
}
bg.setClip(0, 0, bufferRect.width, bufferRect.height);
}
}

/**
* This class provides methods to change the proposed track and save it to the
* real world.
*
* TODO jfreerails.client.renderer is not the most logical place for this class.
*
* @author MystiqueAgent
* @author Luke
*
*/
public class BuildTrackController implements GameModel {
private static final Logger LOGGER = Logger
.getLogger(BuildTrackController.class.getName());
private boolean buildNewTrack = true;
private List<ImPoint> builtTrack = new ArrayList<ImPoint>();
private boolean isBuildTrackSuccessful = false;
private final ModelRoot modelRoot;
private Step[] path;
private TrackPathFinder path4newTrackFinder;
private PathOnTrackFinder pathOnExistingTrackFinder;
private FreerailsPrincipal principal;
private ReadOnlyWorld realWorld;
private SoundManager soundManager = SoundManager.getSoundManager();
private ImPoint startPoint;
private ImPoint targetPoint;
private boolean visible = false;
private WorldDiffs worldDiffs;
/**
* BuildTrackRenderer
*
* @param readOnlyWorld
* ReadOnlyWorld
*/
public BuildTrackController(ReadOnlyWorld readOnlyWorld, ModelRoot modelRoot) {
worldDiffs = new WorldDiffs(readOnlyWorld);
realWorld = readOnlyWorld;
path4newTrackFinder = new TrackPathFinder(readOnlyWorld, modelRoot
.getPrincipal());
pathOnExistingTrackFinder = new PathOnTrackFinder(readOnlyWorld);
this.modelRoot = modelRoot;
principal = modelRoot.getPrincipal();
setWorldDiffs(worldDiffs);
}
/** Utility method that gets the BuildTrackStrategy from the model root. */
private BuildTrackStrategy getBts() {
BuildTrackStrategy btss = (BuildTrackStrategy) modelRoot
.getProperty(ModelRoot.Property.BUILD_TRACK_STRATEGY);
if (null == btss)
throw new NullPointerException();
return btss;
}
/** Utility method that gets the cursor position from the model root. */
private ImPoint getCursorPosition() {
ImPoint point = (ImPoint) modelRoot
.getProperty(ModelRoot.Property.CURSOR_POSITION);
// Check for null & make a defensive copy
point = null == point ? new ImPoint() : point;
if (!modelRoot.getWorld().boundsContain(point.x, point.y)) {
throw new IllegalStateException(String.valueOf(point));
}
return point;
}
/** Hides and cancels any proposed track. */
public void hide() {
this.setVisible(false);
setTargetPoint(null);
reset();
}
/**
* returns <code>true</code> if the track is being build - it is iff the
* build track is shown
*
* @return boolean
*/
public boolean isBuilding() {
return visible;
}
/** Returns true if all the track pieces can be successfully built. */
public boolean isBuildTrackSuccessful() {
return isBuildTrackSuccessful;
}
/** Moves cursor which causes track to be built on the worldDiff object. */
private void moveCursorMoreTiles(List<ImPoint> track) {
moveCursorMoreTiles(track, null);
}
/**
* uses <code>trackBuilder</code> if not null -- otherwise uses own
* <code>buildTrack</code> method - that is applied on
* <code>worldDifferences</code>
*
* @param track
* List
* @param trackBuilder
* TrackMoveProducer
*/
private MoveStatus moveCursorMoreTiles(List<ImPoint> track,
TrackMoveProducer trackBuilder) {
ImPoint oldPosition = getCursorPosition();
if(!Step.checkValidity(oldPosition, track.get(0))){
throw new IllegalStateException(oldPosition.toString()+ " and "+track.get(0).toString());
}
MoveStatus ms = null;
int piecesOfNewTrack = 0;
if (null != trackBuilder) {
trackBuilder.setBuildTrackStrategy(getBts());
}
for (Iterator<ImPoint> iter = track.iterator(); iter.hasNext();) {
ImPoint point = iter.next();
LOGGER.fine("point" + point);
LOGGER.fine("oldPosition" + oldPosition);
if (oldPosition.equals(point)) {
LOGGER.fine("(oldPosition.equals(point))" + point);
continue;
}
Step vector = Step.getInstance(point.x - oldPosition.x, point.y
- oldPosition.y);
// If there is already track between the two tiles, do nothing
FreerailsTile tile = (FreerailsTile) realWorld.getTile(
oldPosition.x, oldPosition.y);
if (tile.getTrackPiece().getTrackConfiguration().contains(vector)) {
oldPosition = point;
continue;
}
piecesOfNewTrack++;
if (trackBuilder != null) {
ms = trackBuilder.buildTrack(oldPosition, vector);
} else {
ms = planBuildingTrack(oldPosition, vector);
}
if (ms.ok) {
setCursorMessage("");
} else {
setCursorMessage(ms.message);
reset();
return ms;
}
oldPosition = point;
}
/* Check whether there is already track at every point. */
if (piecesOfNewTrack == 0) {
MoveStatus moveFailed = MoveStatus.moveFailed("Track already here");
setCursorMessage(moveFailed.message);
return moveFailed;
}
isBuildTrackSuccessful = true;
// If track has actually been built, play the build track sound.
if (trackBuilder != null && ms.isOk()) {
if (trackBuilder.getTrackBuilderMode() == BUILD_TRACK) {
this.soundManager.playSound(
"/jfreerails/client/sounds/buildtrack.wav", 0);
}
}
return ms;
}
/**
* Attempts to building track from the specified point in the specified
* direction on the worldDiff object.
*/
private MoveStatus planBuildingTrack(ImPoint point, Step vector) {
FreerailsTile tileA = (FreerailsTile) worldDiffs.getTile(point.x,
point.y);
BuildTrackStrategy bts = getBts();
int trackTypeAID = bts.getRule(tileA.getTerrainTypeID());
TrackRule trackRuleA = (TrackRule) worldDiffs.get(SKEY.TRACK_RULES,
trackTypeAID);
FreerailsTile tileB = (FreerailsTile) worldDiffs.getTile(point.x
+ vector.deltaX, point.y + vector.deltaY);
int trackTypeBID = bts.getRule(tileB.getTerrainTypeID());
TrackRule trackRuleB = (TrackRule) worldDiffs.get(SKEY.TRACK_RULES,
trackTypeBID);
ChangeTrackPieceCompositeMove move = ChangeTrackPieceCompositeMove
.generateBuildTrackMove(point, vector, trackRuleA, trackRuleB,
worldDiffs, principal);
return move.doMove(worldDiffs, principal);
}
/** Cancels any proposed track and resets the path finder. */
private void reset() {
worldDiffs.reset();
path4newTrackFinder.abandonSearch();
this.builtTrack.clear();
this.isBuildTrackSuccessful = false;
}
int searchStatus() {
if (buildNewTrack) {
return path4newTrackFinder.getStatus();
}
return pathOnExistingTrackFinder.getStatus();
}
/** Utility method that sets the CURSOR_MESSAGE property on the model root. */
private void setCursorMessage(String s) {
modelRoot.setProperty(ModelRoot.Property.CURSOR_MESSAGE, s);
}
/** Sets the proposed track: from the current cursor position to the specified point.*/
public void setProposedTrack(ImPoint to,
TrackMoveProducer trackBuilder) {
ImPoint from = getCursorPosition();
assert (trackBuilder.getTrackBuilderMode() != IGNORE_TRACK);
assert (trackBuilder.getTrackBuilderMode() != BUILD_STATION);
buildNewTrack = trackBuilder.getTrackBuilderMode() == BUILD_TRACK;
/*
* If we have just found the route between the two points, don't waste
* time doing it again.
*/
if (null != targetPoint && null != startPoint
&& targetPoint.equals(to)
&& startPoint.equals(from)
&& searchStatus() != IncrementalPathFinder.SEARCH_NOT_STARTED) {
return;
}
worldDiffs.reset();
builtTrack.clear();
isBuildTrackSuccessful = false;
if (from.equals(to)) {
hide();
return;
}
/* Check both points are on the map. */
if (!realWorld.boundsContain(from.x, from.y)
|| !realWorld.boundsContain(to.x, to.y)) {
hide();
return;
}
setTargetPoint(to);
startPoint = from;
try {
BuildTrackStrategy bts = getBts();
if (buildNewTrack) {
path4newTrackFinder.setupSearch(from, to, bts);
} else {
pathOnExistingTrackFinder.setupSearch(from, to);
}
} catch (PathNotFoundException e) {
setCursorMessage(e.getMessage());
return;
}
updateSearch();
}
/**
* @param newTargetPoint
* The m_targetPoint to set.
*/
private void setTargetPoint(ImPoint newTargetPoint) {
this.targetPoint = newTargetPoint;
ImPoint p = null == newTargetPoint ? null : newTargetPoint;
modelRoot.setProperty(ModelRoot.Property.THINKING_POINT, p);
}
private void setVisible(boolean show) {
if (show == visible) {
return;
}
if (show) {
setWorldDiffs(worldDiffs);
} else {
setWorldDiffs(null);
}
this.visible = show;
}
private void setWorldDiffs(WorldDiffs worldDiffs) {
modelRoot.setProperty(ModelRoot.Property.PROPOSED_TRACK, worldDiffs);
}
public void show() {
this.setVisible(true);
}
public void update() {
// update search for path if necessary.
if (searchStatus() == IncrementalPathFinder.SEARCH_PAUSED) {
updateSearch();
}
}
public void updateUntilComplete() {
while (searchStatus() != IncrementalPathFinder.PATH_FOUND) {
updateSearch();
}
}
/**
* Updates the search, if the search is completed, the proposed track is
* shown.
*/
private void updateSearch() {
try {
if (buildNewTrack) {
path4newTrackFinder.search(100);
} else {
pathOnExistingTrackFinder.search(100);
}
} catch (PathNotFoundException e) {
setCursorMessage(e.getMessage());
return;
}
if (searchStatus() == IncrementalPathFinder.PATH_FOUND) {
if (buildNewTrack) {
builtTrack = path4newTrackFinder.pathAsPoints();
moveCursorMoreTiles(builtTrack);
} else {
boolean okSoFar = true;
path = pathOnExistingTrackFinder.pathAsVectors();
TrackMoveProducer.BuildMode mode = getBuildMode();
int locationX = startPoint.x;
int locationY = startPoint.y;
FreerailsPrincipal fp = modelRoot.getPrincipal();
for (Step v : path) {
Move move;
attemptMove: {
switch (mode) {
case REMOVE_TRACK:
try {
move = ChangeTrackPieceCompositeMove
.generateRemoveTrackMove(new ImPoint(
locationX, locationY), v,
worldDiffs, fp);
break;
} catch (Exception e1) {
e1.printStackTrace();
break attemptMove;
}
case UPGRADE_TRACK:
int owner = ChangeTrackPieceCompositeMove.getOwner(
fp, worldDiffs);
FreerailsTile tile = (FreerailsTile) worldDiffs
.getTile(locationX, locationY);
int tt = tile.getTerrainTypeID();
int trackRuleID = getBts().getRule(tt);
/*
* Skip tiles that already have the right track
* type.
*/
if (trackRuleID == tile.getTrackPiece().getTrackTypeID()) {
break attemptMove;
}
TrackRule trackRule = (TrackRule) worldDiffs.get(
SKEY.TRACK_RULES, trackRuleID);
TrackPiece after = new TrackPieceImpl(tile
.getTrackPiece().getTrackConfiguration(), trackRule, owner,
trackRuleID);
/*
* We don't want to 'upgrade' a station to track.
* See bug 874416.
*/
if (tile.getTrackPiece().getTrackRule().isStation()) {
break attemptMove;
}
move = UpgradeTrackMove.generateMove(tile
.getTrackPiece(), after, new ImPoint(
locationX, locationY));
break;
default:
throw new IllegalStateException(mode.toString());
}// end of switch statement
MoveStatus ms = move.doMove(worldDiffs, fp);
okSoFar = ms.ok && okSoFar;
}// end of attemptMove
locationX += v.deltaX;
locationY += v.deltaY;
}// end for loop
startPoint = new ImPoint(locationX, locationY);
isBuildTrackSuccessful = okSoFar;
if (okSoFar) {
setCursorMessage("");
}
}
show();
}
}
private TrackMoveProducer.BuildMode getBuildMode() {
TrackMoveProducer.BuildMode mode;
mode = (TrackMoveProducer.BuildMode) modelRoot
.getProperty(ModelRoot.Property.TRACK_BUILDER_MODE);
return mode;
}
/**
* Saves track into real world
*/
public ImPoint updateWorld(TrackMoveProducer trackBuilder) {
ImPoint actPoint = getCursorPosition();
if (buildNewTrack) {
if (builtTrack.size() > 0) {
MoveStatus ms = moveCursorMoreTiles(builtTrack, trackBuilder);
/* Note, reset() will have been called if ms.ok == false */
if (ms.ok) {
actPoint = builtTrack.get(builtTrack.size() - 1);
builtTrack = new ArrayList<ImPoint>();
}
}
} else {
trackBuilder.setBuildTrackStrategy(getBts());
MoveStatus ms = trackBuilder.buildTrack(actPoint, path);
//MoveStatus ms = trackBuilder.buildTrack(startPoint, path);
if (ms.ok) {
actPoint = targetPoint;
setCursorMessage("");
if (REMOVE_TRACK == getBuildMode()) {
soundManager.playSound(
"/jfreerails/client/sounds/removetrack.wav", 0);
} else {
soundManager.playSound(
"/jfreerails/client/sounds/buildtrack.wav", 0);
}
} else {
setCursorMessage(ms.message);
reset();
}
}
hide();
return actPoint;
}
}

/**
* This class draws the track being build.
*
* @author MystiqueAgent
* @author Luke
*
*/
public class BuildTrackRenderer implements Painter {
public static final int BIG_DOT_WIDTH = 12;
public static final int SMALL_DOT_WIDTH = 6;
private final ModelRoot modelRoot;
private final Dimension tileSize = new Dimension(30, 30);
private RenderersRoot rr;
public BuildTrackRenderer(RenderersRoot trackPieceViewList,
ModelRoot modelRoot) {
this.modelRoot = modelRoot;
this.rr = trackPieceViewList;
}
private WorldDiffs getWorldDiffs() {
if (modelRoot == null) {
return null;
}
return (WorldDiffs) modelRoot
.getProperty(ModelRoot.Property.PROPOSED_TRACK);
}
/**
* Paints the proposed track and dots to distinguish the proposed track from
* any existing track.
*/
public void paint(Graphics2D g) {
WorldDiffs worldDiffs = getWorldDiffs();
if (null != worldDiffs) {
for (Iterator<ImPoint> iter = worldDiffs.getMapDiffs(); iter
.hasNext();) {
ImPoint point = iter.next();
FreerailsTile fp = (FreerailsTile)worldDiffs.getTile(point.x,
point.y);
TrackPiece tp = fp.getTrackPiece();
int graphicsNumber = tp.getTrackGraphicID();
int ruleNumber = tp.getTrackTypeID();
jfreerails.client.renderer.TrackPieceRenderer trackPieceView = rr
.getTrackPieceView(ruleNumber);
trackPieceView.drawTrackPieceIcon(graphicsNumber, g, point.x,
point.y, tileSize);
}
ReadOnlyWorld realWorld = modelRoot.getWorld();
/*
* Draw small dots for each tile whose track has changed. The dots
* are white if track has been added or upgraded and red if it has
* been removed.
*/
for (Iterator<ImPoint> iter = worldDiffs.getMapDiffs(); iter
.hasNext();) {
ImPoint p = iter.next();
int x = p.x * tileSize.width
+ (tileSize.width - SMALL_DOT_WIDTH) / 2;
int y = p.y * tileSize.width
+ (tileSize.height - SMALL_DOT_WIDTH) / 2;
FreerailsTile before = (FreerailsTile) realWorld.getTile(p.x,
p.y);
FreerailsTile after = (FreerailsTile) worldDiffs.getTile(p.x,
p.y);
boolean trackRemoved = !after.getTrackPiece().getTrackConfiguration().contains(
before.getTrackPiece().getTrackConfiguration());
Color dotColor = trackRemoved ? Color.RED : Color.WHITE;
g.setColor(dotColor);
g.fillOval(x, y, SMALL_DOT_WIDTH, SMALL_DOT_WIDTH);
}
}
}
}

/**
* Paints 2 variations of a tile icon a chequered pattern.
*
* @author Luke Lindsay
*/
final public class ChequeredTileRenderer extends AbstractTileRenderer {
@Override
public int selectTileIcon(int x, int y, ReadOnlyWorld w) {
return (x + y) % 2;
}
public ChequeredTileRenderer(ImageManager imageManager, int[] rgbValues,
TerrainType tileModel) throws IOException {
super(tileModel, rgbValues);
this.setTileIcons(new Image[2]);
this.getTileIcons()[0] = imageManager
.getImage(generateRelativeFileName(0));
this.getTileIcons()[1] = imageManager
.getImage(generateRelativeFileName(1));
}
@Override
public void dumpImages(ImageManager imageManager) {
for (int i = 0; i < this.getTileIcons().length; i++) {
String fileName = generateRelativeFileName(i);
imageManager.setImage(fileName, this.getTileIcons()[i]);
}
}
@Override
protected String generateFileNameNumber(int i) {
return String.valueOf(i);
}
}

/**
* Paints the city names on the map.
*
* @author Scott
*/
public class CityNamesRenderer implements Painter {
private final ReadOnlyWorld w;
public CityNamesRenderer(ReadOnlyWorld world) {
this.w = world;
}
public void paint(Graphics2D g) {
g.setColor(Color.WHITE);
g.setFont(new Font("Arial", 0, 20));
// draw city names onto map
for (int i = 0; i < w.size(SKEY.CITIES); i++) {
CityModel tempCity = (CityModel) w.get(SKEY.CITIES, i);
g.drawString(tempCity.getCityName(), tempCity.getCityX() * 30,
tempCity.getCityY() * 30 + 10);
}
}
}

/**
* Looks to see whether the tiles to the left and right of the same type when
* deciding which tile icon to use.
*
* @author Luke Lindsay
*/
final public class ForestStyleTileRenderer extends
jfreerails.client.renderer.AbstractTileRenderer {
private static final int[] X_LOOK_AT = { -1, 1 };
private static final int[] Y_LOOK_AT = { 0, 0 };
public ForestStyleTileRenderer(ImageManager imageManager, int[] rgbValues,
TerrainType tileModel) throws IOException {
super(tileModel, rgbValues);
this.setTileIcons(new Image[4]);
for (int i = 0; i < this.getTileIcons().length; i++) {
String fileName = generateRelativeFileName(i);
this.getTileIcons()[i] = imageManager.getImage(fileName);
}
}
@Override
public int selectTileIcon(int x, int y, ReadOnlyWorld w) {
int iconNumber = 0;
for (int i = 0; i < 2; i++) {
iconNumber = iconNumber
| checkTile(x + X_LOOK_AT[i], y + Y_LOOK_AT[i], w);
iconNumber = iconNumber << 1;
}
iconNumber = iconNumber >> 1;
return iconNumber;
}
@Override
public void dumpImages(ImageManager imageManager) {
for (int i = 0; i < this.getTileIcons().length; i++) {
String fileName = generateRelativeFileName(i);
imageManager.setImage(fileName, this.getTileIcons()[i]);
}
}
@Override
protected String generateFileNameNumber(int i) {
return BinaryNumberFormatter.format(i, 2);
}
}

/**
* This class encapsulates the objects that make-up and paint the background of
* the map view. At present it is composed of two layers: the terrain layer and
* the track layer.
*
* @author Luke Lindsay 21 September 2001
* @version 1
*/
final public class MapBackgroundRender implements MapLayerRenderer {
private static final Logger logger = Logger
.getLogger(MapBackgroundRender.class.getName());
/**
* The terrain layer.
*/
private final TerrainLayer terrainLayer;
/**
* The track layer.
*/
private final TrackLayer trackLayer;
private final Dimension tileSize = new Dimension(30, 30);
private final Dimension mapSize;
private final Painter cityNames;
private final Painter stationNames;
/*
* Used to avoid having to create a new rectangle for each call to the paint
* methods.
*/
private Rectangle clipRectangle = new Rectangle();
/**
* This inner class represents a view of the track on the map.
*
* @author Luke Lindsay 21 September 2001
*/
final public class TrackLayer implements MapLayerRenderer {
private final ReadOnlyWorld w;
private final RenderersRoot rr;
/**
* Paints a rectangle of tiles onto the supplied graphics context.
*
* @param g
* The graphics context on which the tiles get painted.
* @param tilesToPaint
* The rectangle, measured in tiles, to paint.
*/
public void paintRectangleOfTiles(Graphics g, Rectangle tilesToPaint) {
/*
* Track can overlap the adjacent terrain tiles by half a tile. This
* means that we need to paint the track from the tiles bordering
* the specified rectangle of tiles (tilesToPaint). To prevent
* unnecessary painting, we set the clip to expose only the rectangle
* of tilesToPaint.
*/
Graphics tempG = g;
Point tile = new Point();
for (tile.x = tilesToPaint.x - 1; tile.x < (tilesToPaint.x
+ tilesToPaint.width + 1); tile.x++) {
for (tile.y = tilesToPaint.y - 1; tile.y < (tilesToPaint.y
+ tilesToPaint.height + 1); tile.y++) {
if ((tile.x >= 0) && (tile.x < mapSize.width)
&& (tile.y >= 0) && (tile.y < mapSize.height)) {
FreerailsTile ft = (FreerailsTile)w.getTile(tile.x, tile.y);
TrackPiece tp = ft.getTrackPiece();
int graphicsNumber = tp.getTrackGraphicID();
int ruleNumber = tp.getTrackTypeID();
if (ruleNumber != NullTrackType.NULL_TRACK_TYPE_RULE_NUMBER) {
TrackPieceRenderer trackPieceView = rr.getTrackPieceView(ruleNumber);
trackPieceView.drawTrackPieceIcon(graphicsNumber,
tempG, tile.x, tile.y, tileSize);
}
}
}
}
}
public void paintTile(Graphics g, int tileX, int tileY) {
/*
* Since track tiles overlap the adjacent terrain tiles, we create a
* temporary Graphics object that only lets us draw on the selected
* tile.
*/
paintRectangleOfTiles(g, new Rectangle(tileX, tileY, 1, 1));
}
private void paintRectangleOfTiles(Graphics g, int x, int y, int width,
int height) {
paintRectangleOfTiles(g, new Rectangle(x, y, width, height));
}
public void refreshTile(int x, int y) {
}
public void paintRect(Graphics g, Rectangle visibleRect) {
throw new UnsupportedOperationException(
"Method not yet implemented.");
}
public TrackLayer(ReadOnlyWorld world,
RenderersRoot trackPieceViewList) {
this.rr = trackPieceViewList;
this.w = world;
}
public void refreshAll() {
}
}
/**
* This inner class represents the terrain of the map.
*
* @author Luke Lindsay 21 September 2001
*/
final public class TerrainLayer implements MapLayerRenderer {
private final TileRendererList tiles;
private final ReadOnlyWorld w;
public void paintTile(Graphics g, Point tile) {
int screenX = tileSize.width * tile.x;
int screenY = tileSize.height * tile.y;
if ((tile.x >= 0) && (tile.x < mapSize.width) && (tile.y >= 0)
&& (tile.y < mapSize.height)) {
TerrainTile tt = (TerrainTile) w.getTile(tile.x, tile.y);
int typeNumber = tt.getTerrainTypeID();
TileRenderer tr = tiles.getTileViewWithNumber(typeNumber);
if (null == tr) {
logger.warning("No tile renderer for " + typeNumber);
} else {
tr.renderTile(g, screenX, screenY, tile.x, tile.y, w);
}
}
}
/**
* Paints a rectangle of tiles on the supplied graphics context.
*
* @param g
* The graphics context.
* @param tilesToPaint
* The rectangle, measured in tiles, to paint.
*/
public void paintRectangleOfTiles(Graphics g, Rectangle tilesToPaint) {
Point tile = new Point();
for (tile.x = tilesToPaint.x; tile.x < (tilesToPaint.x + tilesToPaint.width); tile.x++) {
for (tile.y = tilesToPaint.y; tile.y < (tilesToPaint.y + tilesToPaint.height); tile.y++) {
terrainLayer.paintTile(g, tile);
}
}
}
public void paintRect(Graphics g, Rectangle visibleRect) {
throw new UnsupportedOperationException(
"Method not yet implemented.");
}
public void paintTile(Graphics g, int tileX, int tileY) {
paintTile(g, new Point(tileX, tileY));
}
private void paintRectangleOfTiles(Graphics g, int x, int y, int width,
int height) {
paintRectangleOfTiles(g, new Rectangle(x, y, width, height));
}
public void refreshTile(int x, int y) {
}
public TerrainLayer(ReadOnlyWorld world, TileRendererList tiles) {
this.w = world;
this.tiles = tiles;
}
public void refreshAll() {
}
}
public MapBackgroundRender(ReadOnlyWorld w, RenderersRoot rr,
ModelRoot modelRoot) {
trackLayer = new TrackLayer(w, rr);
terrainLayer = new TerrainLayer(w, rr);
mapSize = new Dimension(w.getMapWidth(), w.getMapHeight());
cityNames = new CityNamesRenderer(w);
stationNames = new StationNamesRenderer(w, modelRoot);
}
public void paintTile(Graphics g, int x, int y) {
terrainLayer.paintTile(g, x, y);
trackLayer.paintTile(g, x, y);
cityNames.paint((Graphics2D) g);
stationNames.paint((Graphics2D) g);
}
public void paintRect(Graphics g, Rectangle visibleRect) {
int tileWidth = 30;
int tileHeight = 30;
clipRectangle = g.getClipBounds(clipRectangle);
int x = clipRectangle.x / tileWidth;
int y = clipRectangle.y / tileHeight;
int width = (clipRectangle.width / tileWidth) + 2;
int height = (clipRectangle.height) / tileHeight + 2;
paintRectangleOfTiles(g, x, y, width, height);
cityNames.paint((Graphics2D) g);
stationNames.paint((Graphics2D) g);
}
private void paintRectangleOfTiles(Graphics g, int x, int y, int width,
int height) {
terrainLayer.paintRectangleOfTiles(g, x, y, width, height);
trackLayer.paintRectangleOfTiles(g, x, y, width, height);
cityNames.paint((Graphics2D) g);
stationNames.paint((Graphics2D) g);
}
public void refreshTile(int x, int y) {
// Do nothing
}
public void refreshAll() {
// Do nothing
}
}

/**
* Paints a layer of the map which might be buffered.
*
* @author Luke Lindsay
*/
public interface MapLayerRenderer {
void paintTile(Graphics g, int tileX, int tileY);
void refreshTile(int x, int y);
void refreshAll();
void paintRect(Graphics g, Rectangle visibleRect);
}

/**
* Lets the GUI component that is displaying the map known the scale at which
* the map is being rendered.
*
* @author Luke
*/
public interface MapRenderer extends MapLayerRenderer {
float getScale();
Dimension getMapSizeInPixels();
}

class MyRenderersRoot implements RenderersRoot {
static ImageManager imageManager = new ImageManagerImpl("/jfreerails/client/graphics/");
private TrainImages trainImages;
public MyRenderersRoot() {
try {
this.trainImages = new TrainImages(imageManager, "mail");
} catch (IOException ex) {
Logger.getLogger(MyRenderersRoot.class.getName()).log(Level.SEVERE, null, ex);
fail();
}
}
@Override
public TrackPieceRenderer getTrackPieceView(int i) {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public TrainImages getWagonImages(int type) {
return this.trainImages;
}
@Override
public TrainImages getEngineImages(int type) {
return this.trainImages;
}
@Override
public boolean validate(ReadOnlyWorld world) {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public Image getImage(String relativeFilename) throws IOException {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public Image getScaledImage(String relativeFilename, int height) throws IOException {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public TileRenderer getTileViewWithNumber(int i) {
throw new UnsupportedOperationException("Not supported yet.");
}
}

/**
* This class implements the TrackPieceView interface, but intentionally does
* nothing. Its methods are called when drawing tiles with no track.
*
* @author Luke
*/
final public class NullTrackPieceRenderer implements TrackPieceRenderer {
public static final NullTrackPieceRenderer instance = new NullTrackPieceRenderer();
private NullTrackPieceRenderer() {
}
/*
* @see TrackPieceView#getTrackPieceIcon(int)
*/
public Image getTrackPieceIcon(int trackTemplate) {
return null;
}
/*
* @see TrackPieceView#drawTrackPieceIcon(int, Graphics, int, int,
* Dimension)
*/
public void drawTrackPieceIcon(int trackTemplate, Graphics g, int x, int y,
Dimension tileSize) {
// Draw nothing since there no track here.
}
public void dumpImages(ImageManager imageManager) {
// TODO Auto-generated method stub
}
}

/**
* Provides access to the objects that render terrain, track, and trains.
*
* @author Luke
*/
public interface RenderersRoot extends TileRendererList {
TrackPieceRenderer getTrackPieceView(int i);
TrainImages getWagonImages(int type);
TrainImages getEngineImages(int type);
//OldTrainImages getTrainImages();
boolean validate(ReadOnlyWorld world);
Image getImage(String relativeFilename) throws IOException;
Image getScaledImage(String relativeFilename, int height) throws IOException;
}

/**
* Selects a tile icon to use based on the type of the tiles to the North, East,
* South and West.
*
* @author Luke Lindsay
*/
final public class RiverStyleTileRenderer extends
jfreerails.client.renderer.AbstractTileRenderer {
private static final int[] Y_LOOK_AT = { 0, 1, 0, -1 };
private static final int[] X_LOOK_AT = { -1, 0, 1, 0 };
public RiverStyleTileRenderer(ImageManager imageManager, int[] rgbValues,
TerrainType tileModel) throws IOException {
super(tileModel, rgbValues);
this.setTileIcons(new Image[16]);
for (int i = 0; i < this.getTileIcons().length; i++) {
String fileName = generateRelativeFileName(i);
this.getTileIcons()[i] = imageManager.getImage(fileName);
}
}
@Override
public int selectTileIcon(int x, int y, ReadOnlyWorld w) {
int iconNumber = 0;
for (int i = 0; i < 4; i++) {
iconNumber = iconNumber << 1;
iconNumber = iconNumber
| checkTile(x + X_LOOK_AT[i], y + Y_LOOK_AT[i], w);
}
return iconNumber;
}
@Override
public void dumpImages(ImageManager imageManager) {
for (int i = 0; i < this.getTileIcons().length; i++) {
imageManager.setImage(generateRelativeFileName(i), this
.getTileIcons()[i]);
}
}
@Override
protected String generateFileNameNumber(int i) {
return BinaryNumberFormatter.formatWithLowBitOnLeft(i, 4);
}
}

/**
* A special tile's icon gets drawn over the icon of a normal tile.
*
* @author Luke Lindsay
*/
final public class SpecialTileRenderer extends AbstractTileRenderer {
private static final Logger logger = Logger
.getLogger(SpecialTileRenderer.class.getName());
final private TileRenderer parentTileView;
@Override
public void renderTile(java.awt.Graphics g, int renderX, int renderY,
int mapX, int mapY, ReadOnlyWorld w) {
if (parentTileView != null) {
parentTileView.renderTile(g, renderX, renderY, mapX, mapY, w);
} else {
logger.warning("parent tileView==null");
}
Image icon = this.getIcon(mapX, mapX, w);
if (null != icon) {
g.drawImage(icon, renderX, renderY, null);
} else {
logger.warning("special tileView icon==null");
}
}
@Override
public int selectTileIcon(int x, int y, ReadOnlyWorld w) {
return 0;
}
public SpecialTileRenderer(ImageManager imageManager, int[] rgbValues,
TerrainType tileModel, TileRenderer parentTileView)
throws IOException {
super(tileModel, rgbValues);
this.setTileIcons(new Image[1]);
this.getTileIcons()[0] = imageManager.getImage(generateFilename());
this.parentTileView = parentTileView;
}
@Override
public void dumpImages(ImageManager imageManager) {
imageManager.setImage(generateFilename(), this.getTileIcons()[0]);
}
private String generateFilename() {
return "terrain" + File.separator + this.getTerrainType() + ".png";
}
@Override
protected String generateFileNameNumber(int i) {
throw new UnsupportedOperationException();
}
}

/**
* This class stores a buffer containing the terrain and track layers of current
* visible rectangle of the map. It is responsible of painting these layers and
* updating the buffer when the map scrolls or tiles are updated.
*
* @author Luke Lindsay 01 November 2001
* @version 1.0
*/
final public class SquareTileBackgroundRenderer extends BufferedTiledBackgroundRenderer {
private final MapLayerRenderer mapView;
@Override
protected void paintBufferRectangle(int x, int y, int width, int height) {
// Fix for bug [ 1303162 ]
// If the buffer hasn't been set yet, don't try and refresh it!
if (null != super.backgroundBuffer) {
Graphics gg = bg.create();
gg.setClip(x, y, width, height);
gg.translate(-bufferRect.x, -bufferRect.y);
mapView.paintRect(gg, bufferRect);
}
}
public SquareTileBackgroundRenderer(MapLayerRenderer mv) {
if (null == mv) {
throw new NullPointerException();
}
this.mapView = mv;
}
public void paintTile(Graphics g, int tileX, int tileY) {
mapView.paintTile(g, tileX, tileY);
}
public void refreshTile(int x, int y) {
// The backgroundBuffer gets created on the first call to
// backgroundBuffer.paintRect(..)
// so we need a check here to avoid a null pointer exception.
if (null != super.backgroundBuffer) {
Graphics gg = bg.create();
gg.translate(-bufferRect.x, -bufferRect.y);
mapView.paintTile(gg, x, y);
}
}
}

/**
* Paints a tile for which there only one tile icon.
*
* @author Luke Lindsay
*/
final public class StandardTileRenderer extends
jfreerails.client.renderer.AbstractTileRenderer {
public StandardTileRenderer(ImageManager imageManager, int[] rgbValues,
TerrainType tileModel) throws IOException {
super(tileModel, rgbValues);
this.setTileIcons(new Image[1]);
this.getTileIcons()[0] = imageManager.getImage(generateFilename());
}
@Override
public void dumpImages(ImageManager imageManager) {
imageManager.setImage(generateFilename(), this.getTileIcons()[0]);
}
private String generateFilename() {
return generateFilename(this.getTerrainType());
}
public static String generateFilename(String typeName) {
return "terrain" + File.separator + typeName + ".png";
}
@Override
protected String generateFileNameNumber(int i) {
throw new UnsupportedOperationException();
}
}

/**
* Renders box showing the cargo waiting at a station.
*
* @author Luke
*/
public class StationBoxRenderer implements Painter {
private static final int WAGON_IMAGE_HEIGHT = 10;
private static final int SPACING = 3;
private static final int MAX_WIDTH = 80;
private final ReadOnlyWorld w;
private final Color bgColor;
private final int wagonImageWidth;
private final ModelRoot modelRoot;
private final Image[] cargoImages;
private static final int MAX_HEIGHT = 5 * (WAGON_IMAGE_HEIGHT + SPACING);
public StationBoxRenderer(ReadOnlyWorld world, RenderersRoot vl,
ModelRoot modelRoot) {
this.w = world;
this.bgColor = new Color(0, 0, 200, 60);
this.modelRoot = modelRoot;
// How wide will the wagon images be if we scale them so their height is
// WAGON_IMAGE_HEIGHT?
Image wagonImage = vl.getWagonImages(0).getSideOnImage();
wagonImageWidth = wagonImage.getWidth(null) * WAGON_IMAGE_HEIGHT
/ wagonImage.getHeight(null);
int nrOfCargoTypes = w.size(SKEY.CARGO_TYPES);
cargoImages = new Image[nrOfCargoTypes];
for (int i = 0; i < nrOfCargoTypes; i++) {
String wagonFilename = vl.getWagonImages(i).sideOnFileName;
try {
wagonImage = vl.getScaledImage(wagonFilename,
WAGON_IMAGE_HEIGHT);
} catch (IOException e) {
throw new IllegalArgumentException(wagonFilename);
}
cargoImages[i] = wagonImage;
}
}
public void paint(Graphics2D g) {
Boolean showCargoWaiting = (Boolean) modelRoot
.getProperty(ModelRoot.Property.SHOW_CARGO_AT_STATIONS);
if (showCargoWaiting.booleanValue()) {
/* We only show the station boxes for the current player. */
FreerailsPrincipal principal = modelRoot.getPrincipal();
WorldIterator wi = new NonNullElements(KEY.STATIONS, w, principal);
while (wi.next()) { // loop over non null stations
StationModel station = (StationModel) wi.getElement();
int positionX = (station.getStationX() * Constants.TILE_SIZE)
+ Constants.TILE_SIZE / 2;
int positionY = (station.getStationY() * Constants.TILE_SIZE)
+ Constants.TILE_SIZE * 2;
Rectangle r = new Rectangle(positionX, positionY, MAX_WIDTH,
MAX_HEIGHT);
g.setColor(bgColor);
g.fillRect(positionX, positionY, MAX_WIDTH, MAX_HEIGHT);
g.setColor(Color.WHITE);
g.setStroke(new BasicStroke(1f));
g.drawRect(positionX, positionY, MAX_WIDTH, MAX_HEIGHT);
ImmutableCargoBundle cb = (ImmutableCargoBundle) w.get(
principal, KEY.CARGO_BUNDLES, station
.getCargoBundleID());
int[][] carsLoads = calculateCarLoads(cb);
for (int category = 0; category < CargoType
.getNumberOfCategories(); category++) {
int alternateWidth = (MAX_WIDTH - 2 * SPACING)
/ (carsLoads[category].length + 1);
int xOffsetPerWagon = Math.min(wagonImageWidth,
alternateWidth);
for (int car = 0; car < carsLoads[category].length; car++) {
int x = positionX + (car * xOffsetPerWagon)
+ SPACING;
int y = positionY
+ (category * (WAGON_IMAGE_HEIGHT + SPACING));
int cargoType = carsLoads[category][car];
g.drawImage(cargoImages[cargoType], x, y, null);
}
}
}
}
}
/**
* The length of the returned array is the number of complete carloads of
* the specified cargo category in the specified bundle. The values in the
* array are the type of the cargo. E.g. if the bundle contained 2 carloads
* of cargo type 3 and 1 of type 7, {3, 3, 7} would be returned.
*/
private int[][] calculateCarLoads(ImmutableCargoBundle cb) {
int categories = CargoType.getNumberOfCategories();
int numCargoTypes = w.size(SKEY.CARGO_TYPES);
int[] numberOfCarLoads = new int[categories];
int[][] cars = new int[categories][numCargoTypes];
for (int i = 0; i < numCargoTypes; i++) {
CargoType ct = (CargoType) w.get(SKEY.CARGO_TYPES, i);
int carsOfThisCargo = cb.getAmount(i)
/ WagonType.UNITS_OF_CARGO_PER_WAGON;
numberOfCarLoads[ct.getCategory().getNumber()] += carsOfThisCargo;
cars[ct.getCategory().getNumber()][i] += carsOfThisCargo;
}
int[][] returnMatrix = new int[categories][];
for (int category = 0; category < categories; category++) {
int[] returnValue = new int[numberOfCarLoads[category]];
int arrayIndex = 0;
for (int cargoType = 0; cargoType < numCargoTypes; cargoType++) {
for (int j = 0; j < cars[category][cargoType]; j++) {
returnValue[arrayIndex] = cargoType;
arrayIndex++;
}
}
returnMatrix[category] = returnValue;
}
return returnMatrix;
}
}

/**
*
* Class to render the station names and spheres of influence on the game map.
* Names are retrieved from the KEY.STATIONS object. Date: 14th April 2003 28
* May 2004 updated to also show station sphere of influence.
*
* @author Scott Bennett
* @author Luke Lindsay
*
*/
public class StationNamesRenderer implements Painter {
private final ReadOnlyWorld w;
private final ModelRoot modelRoot;
private final int fontSize;
private final Color bgColor;
private final Color textColor;
final static float[] dash1 = { 5.0f };
final static BasicStroke dashed = new BasicStroke(1.0f,
BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f, dash1, 0.0f);
private final Font font;
public StationNamesRenderer(ReadOnlyWorld world, ModelRoot modelRoot) {
this.w = world;
this.modelRoot = modelRoot;
this.fontSize = 10;
this.bgColor = Color.BLACK;
this.textColor = Color.WHITE;
font = new Font("Arial", 0, fontSize);
}
public void paint(Graphics2D g) {
int rectWidth;
int rectHeight;
int rectX;
int rectY;
float visibleAdvance;
float textX;
float textY;
StationModel tempStation;
String stationName;
int positionX;
int positionY;
Boolean showStationNames = (Boolean) modelRoot
.getProperty(ModelRoot.Property.SHOW_STATION_NAMES);
Boolean showStationBorders = (Boolean) modelRoot
.getProperty(ModelRoot.Property.SHOW_STATION_BORDERS);
FontRenderContext frc = g.getFontRenderContext();
TextLayout layout;
for (int i = 0; i < w.getNumberOfPlayers(); i++) {
FreerailsPrincipal principal = w.getPlayer(i).getPrincipal();
// draw station names onto map
WorldIterator wi = new NonNullElements(KEY.STATIONS, w, principal);
while (wi.next()) { // loop over non null stations
tempStation = (StationModel) wi.getElement();
int x = tempStation.getStationX();
int y = tempStation.getStationY();
// First draw station sphere of influence
if (showStationBorders.booleanValue()) {
FreerailsTile tile = (FreerailsTile) w.getTile(x, y);
int radius = tile.getTrackPiece().getTrackRule().getStationRadius();
int diameterInPixels = (radius * 2 + 1) * 30;
int radiusX = (x - radius) * 30;
int radiusY = (y - radius) * 30;
g.setColor(Color.WHITE);
g.setStroke(dashed);
g.draw(new RoundRectangle2D.Double(radiusX, radiusY,
diameterInPixels, diameterInPixels, 10, 10));
}
// Then draw the station name.
if (showStationNames.booleanValue()) {
stationName = tempStation.getStationName();
positionX = (x * 30) + 15;
positionY = (y * 30) + 30;
layout = new TextLayout(stationName, font, frc);
visibleAdvance = layout.getVisibleAdvance();
rectWidth = (int) (visibleAdvance * 1.2);
rectHeight = (int) (fontSize * 1.5);
rectX = (positionX - (rectWidth / 2));
rectY = positionY;
g.setColor(bgColor);
g.fillRect(rectX, rectY, rectWidth, rectHeight);
textX = (positionX - (visibleAdvance / 2));
textY = positionY + fontSize + 1;
g.setColor(textColor);
layout.draw(g, textX, textY);
g.setStroke(new BasicStroke(1.0f));
// draw a border 1 pixel inside the edges of the rectangle
g.draw(new Rectangle(rectX + 1, rectY + 1, rectWidth - 3,
rectHeight - 3));
}
}
}
// end FOR loop
}
// paint method
}

/**
* This class draws the radius of a station on the map.
*
* @author Luke
*/
public class StationRadiusRenderer implements Painter {
/**
* Border colour to use when placement is OK.
*/
public static final Color COLOR_OK = Color.WHITE;
/**
* Border colour to use when placement is not allowed.
*/
public static final Color COLOR_CANNOT_BUILD = Color.RED;
/**
* Colour of the highlighted border.
*/
private Color borderColor = COLOR_OK;
private static final int tileSize = 30;
private int radius = 2;
private int x;
private int y;
private final ModelRoot modelRoot;
public StationRadiusRenderer(ModelRoot mr) {
this.modelRoot = mr;
}
public void setBorderColor(Color c) {
borderColor = c;
}
public void setPosition(int x, int y) {
this.x = x;
this.y = y;
}
public void setRadius(int radius) {
this.radius = radius;
}
public void show() {
if (!modelRoot
.is(Property.CURSOR_MODE, Value.PLACE_STATION_CURSOR_MODE)) {
modelRoot.setProperty(Property.PREVIOUS_CURSOR_MODE, modelRoot
.getProperty(Property.CURSOR_MODE));
modelRoot.setProperty(Property.CURSOR_MODE,
Value.PLACE_STATION_CURSOR_MODE);
modelRoot.setProperty(Property.IGNORE_KEY_EVENTS, Boolean.TRUE);
}
}
public void hide() {
ModelRoot.Value lastCursorMode = (ModelRoot.Value) modelRoot
.getProperty(ModelRoot.Property.PREVIOUS_CURSOR_MODE);
assert !lastCursorMode
.equals(ModelRoot.Value.PLACE_STATION_CURSOR_MODE);
modelRoot.setProperty(ModelRoot.Property.CURSOR_MODE, lastCursorMode);
modelRoot.setProperty(Property.IGNORE_KEY_EVENTS, Boolean.FALSE);
}
public void paint(Graphics2D g) {
if (modelRoot.getProperty(ModelRoot.Property.CURSOR_MODE).equals(
Value.PLACE_STATION_CURSOR_MODE)) {
g.setStroke(new BasicStroke(2f));
g.setColor(borderColor);
g.drawRect(tileSize * (x - radius), tileSize * (y - radius),
tileSize * (2 * radius + 1), tileSize * (2 * radius + 1));
}
}
}

/**
* Draws an icon to represent a tile.
*
* @author Luke Lindsay
*
*/
public interface TileRenderer {
Image getDefaultIcon();
void renderTile(java.awt.Graphics g, int renderX, int renderY, int mapX,
int mapY, ReadOnlyWorld w);
/** Adds the images this TileRenderer uses to the specified ImageManager. */
void dumpImages(ImageManager imageManager);
}

/**
* A list of TileRenderers.
*
* @author Luke Lindsay 09 October 2001
*/
public interface TileRendererList {
TileRenderer getTileViewWithNumber(int i);
/**
* Checks whether this tile view list has tile views for all the terrain
* types in the specified list.
*/
boolean validate(ReadOnlyWorld world);
}

/**
* A list of TileRenderers stored in an array and created from an ArrayList.
*
* @author Luke Lindsay 09 October 2001
*/
final public class TileRendererListImpl implements TileRendererList {
private final TileRenderer[] tiles;
public TileRenderer getTileViewWithNumber(int i) {
return tiles[i];
}
public TileRendererListImpl(ArrayList<TileRenderer> t) {
tiles = new TileRenderer[t.size()];
for (int i = 0; i < t.size(); i++) {
tiles[i] = t.get(i);
}
}
public boolean validate(ReadOnlyWorld w) {
// There should a TileRenderer for each terrain type.
return w.size(SKEY.TERRAIN_TYPES) == tiles.length;
}
}

/**
* Draws an icon to represent a track piece.
*
* @author Luke Lindsay 09 October 2001
*/
public interface TrackPieceRenderer {
Image getTrackPieceIcon(int trackTemplate);
void drawTrackPieceIcon(int trackTemplate, java.awt.Graphics g, int x,
int y, java.awt.Dimension tileSize);
/** Adds the images this TileRenderer uses to the specified ImageManager. */
void dumpImages(ImageManager imageManager);
}

/**
* This class renders a track piece.
*
* @author Luke Lindsay 09 October 2001
*/
final public class TrackPieceRendererImpl implements TrackPieceRenderer {
private final Image[] trackPieceIcons = new Image[512];
private final String typeName;
public void drawTrackPieceIcon(int trackTemplate, java.awt.Graphics g,
int x, int y, java.awt.Dimension tileSize) {
if ((trackTemplate > 511) || (trackTemplate < 0)) {
throw new java.lang.IllegalArgumentException("trackTemplate = "
+ trackTemplate + ", it should be in the range 0-511");
}
if (trackPieceIcons[trackTemplate] != null) {
int drawX = x * tileSize.width - tileSize.width / 2;
int drawY = y * tileSize.height - tileSize.height / 2;
g.drawImage(trackPieceIcons[trackTemplate], drawX, drawY, null);
}
}
public TrackPieceRendererImpl(ReadOnlyWorld w, ImageManager imageManager,
int typeNumber) throws IOException {
TrackRule trackRule = (TrackRule) w.get(SKEY.TRACK_RULES, typeNumber);
this.typeName = trackRule.getTypeName();
for (int i = 0; i < 512; i++) {
if (trackRule.testTrackPieceLegality(i)) {
String fileName = generateFilename(i, getTrackTypeName());
trackPieceIcons[i] = imageManager.getImage(fileName);
}
}
}
public Image getTrackPieceIcon(int trackTemplate) {
if ((trackTemplate > 511) || (trackTemplate < 0)) {
throw new java.lang.IllegalArgumentException("trackTemplate = "
+ trackTemplate + ", it should be in the range 0-511");
}
return trackPieceIcons[trackTemplate];
}
public void dumpImages(ImageManager imageManager) {
for (int i = 0; i < 512; i++) {
if (trackPieceIcons[i] != null) {
String fileName = generateFilename(i, getTrackTypeName());
imageManager.setImage(fileName, trackPieceIcons[i]);
}
}
}
public static String generateFilename(int i, String trackTypeName) {
String relativeFileNameBase = "track" + File.separator + trackTypeName;
int newTemplate = TrackConfiguration.from9bitTemplate(i)
.get8bitTemplate();
String fileName = relativeFileNameBase + "_"
+ BinaryNumberFormatter.formatWithLowBitOnLeft(newTemplate, 8)
+ ".png";
return fileName;
}
private String getTrackTypeName() {
return typeName;
}
}

/**
* A list of TrackPieceRenderers.
*
* @author Luke
*/
final public class TrackPieceRendererList {
private static final Logger logger = Logger
.getLogger(TrackPieceRendererList.class.getName());
private final TrackPieceRenderer[] trackPieceViewArray;
public TrackPieceRenderer getTrackPieceView(int i) {
if (NullTrackType.NULL_TRACK_TYPE_RULE_NUMBER == i) {
return NullTrackPieceRenderer.instance;
}
return trackPieceViewArray[i];
}
public TrackPieceRendererList(ReadOnlyWorld w, ImageManager imageManager,
FreerailsProgressMonitor pm) throws IOException {
// Setup progress monitor..
pm.nextStep(w.size(SKEY.TRACK_RULES));
int progress = 0;
pm.setValue(progress);
int numberOfTrackTypes = w.size(SKEY.TRACK_RULES);
trackPieceViewArray = new TrackPieceRenderer[numberOfTrackTypes];
for (int i = 0; i < numberOfTrackTypes; i++) {
trackPieceViewArray[i] = new TrackPieceRendererImpl(w,
imageManager, i);
pm.setValue(++progress);
}
}
public boolean validate(ReadOnlyWorld w) {
boolean okSoFar = true;
for (int i = 0; i < w.size(SKEY.TRACK_RULES); i++) {
TrackRule trackRule = (TrackRule) w.get(SKEY.TRACK_RULES, i);
Iterator<TrackConfiguration> legalConfigurationsIterator = trackRule
.getLegalConfigurationsIterator();
TrackPieceRenderer trackPieceView = this.getTrackPieceView(i);
if (null == trackPieceView) {
logger
.warning("No track piece view for the following track type: "
+ trackRule.getTypeName());
return false;
}
while (legalConfigurationsIterator.hasNext()) {
TrackConfiguration trackConfig = legalConfigurationsIterator
.next();
int trackGraphicsNo = trackConfig.getTrackGraphicsID();
Image img = trackPieceView.getTrackPieceIcon(trackGraphicsNo);
if (null == img) {
logger
.warning("No track piece image for the following track type: "
+ trackRule.getTypeName()
+ ", with configuration: "
+ trackGraphicsNo);
okSoFar = false;
}
}
}
return okSoFar;
}
}

/**
* Stores side-on and over-head images of a particular wagon or engine type.
*
* @author Luke
*
*
*/
public class TrainImages {
public enum Highlight{SELECTED, FOCUSED};
private final Image sideOnImage;
private final Image[] overheadImages = new Image[8];
private final Image[] overheadSelectedImages = new Image[8];
private final Image[] overheadFocusedImages = new Image[8];
public final String sideOnFileName;
public Image getSideOnImage() {
return sideOnImage;
}
public Image getOverheadImage(int direction) {
return overheadImages[direction];
}
/**
* @param direction
* @return the image to render under the wagon/engine image
* when the train is selects/focused.
*/
public Image getOverheadHighlightImage(int direction, Highlight h) {
if(h == Highlight.FOCUSED)
return overheadFocusedImages[direction];
if(h == Highlight.SELECTED)
return overheadSelectedImages[direction];
return null;
}
public static String generateOverheadFilename(String name, int i) {
Step[] vectors = Step.getList();
return "trains" + File.separator + "overhead" + File.separator + name
+ "_" + vectors[i].toAbrvString() + ".png";
}
public static String generateSideOnFilename(String name) {
return "trains" + File.separator + "sideon" + File.separator + name
+ ".png";
}
public TrainImages(ImageManager imageManager, String name) throws IOException {
sideOnFileName = TrainImages.generateSideOnFilename(name);
sideOnImage = imageManager.getImage(sideOnFileName);
for (int direction = 0; direction < 8; direction++) {
overheadImages[direction] = imageManager
.getImage(generateOverheadFilename(name, direction));
overheadSelectedImages[direction] = imageManager
.getImage(generateOverheadFilename("highlights" + File.separator + "selected", direction));
overheadFocusedImages[direction] = imageManager
.getImage(generateOverheadFilename("highlights" + File.separator + "focused", direction));
}
}
}

/**
* This class draws a train from an overhead view.
*
* Also has a method that determines if a mouse click was on a train.
*
* @author Luke Lindsay 13-Oct-2002
*
*/
public class TrainRenderer {
private final RenderersRoot rr;
public TrainRenderer(RenderersRoot trainImages) {
this.rr = trainImages;
}
/**
* Calculates the positions of the engine and each wagon on the map.
* Intended to be used for rendering trains, for rendering highlights
* around trains, and for determining if a mouse click was on a train.
*
* @param train
* @param s
* @return List of positions, one entry for the engine and one for each
* wagon.
*/
public List<Entry<Point, Step>> calcPositions(TrainModel train, TrainPositionOnMap s) {
List<Entry<Point, Step>> positions = new ArrayList<>(train.getLength() + 1);
FreerailsPathIterator it = s.path();
PathWalker pw = new PathWalkerImpl(it);
// Engine + wagons
for (int i = 0; i < train.getNumberOfWagons() + 1; i++) {
IntLine wagon = new IntLine();
IntLine line = new IntLine();
pw.stepForward(16);
boolean firstIteration = true;
while (pw.hasNext()) {
pw.nextSegment(line);
if (firstIteration) {
wagon.x1 = line.x1;
wagon.y1 = line.y1;
firstIteration = false;
}
}
wagon.x2 = line.x2;
wagon.y2 = line.y2;
Step v = Step
.getNearestVector(wagon.x2 - wagon.x1, wagon.y2 - wagon.y1);
Point wagonCenter = new Point((wagon.x2 + wagon.x1) / 2,
(wagon.y2 + wagon.y1) / 2);
positions.add(new AbstractMap.SimpleImmutableEntry<>(wagonCenter, v));
// The gap between wagons
pw.stepForward(8);
while (pw.hasNext()) {
pw.nextSegment(line);
}
}
return positions;
}
public void paintTrain(Graphics g, TrainModel train, List<Entry<Point, Step>> positions) {
for (int i = 0; i < positions.size(); i++) {
TrainImages trainImages;
if (i == 0) {
trainImages = rr.getEngineImages(train.getEngineType());
} else {
int type = train.getWagon(i - 1);
trainImages = rr.getWagonImages(type);
}
Entry<Point, Step> entry = positions.get(i);
Image image = trainImages.getOverheadImage(entry.getValue().getID());
Point p = entry.getKey();
g.drawImage(image, p.x - 15, p.y - 15, null);
}
}
public void paintTrainHighlight(Graphics g, TrainModel train, List<Entry<Point, Step>> positions, TrainImages.Highlight highlight) {
for (int i = 0; i < positions.size(); i++) {
TrainImages trainImages;
if (i == 0) {
trainImages = rr.getEngineImages(train.getEngineType());
} else {
int type = train.getWagon(i - 1);
trainImages = rr.getWagonImages(type);
}
Entry<Point, Step> entry = positions.get(i);
Image image = trainImages.getOverheadHighlightImage(entry.getValue().getID(), highlight);
Point p = entry.getKey();
g.drawImage(image, p.x - 15, p.y - 15, null);
}
}
public boolean isHit(Point mousePosition, TrainModel train, List<Entry<Point, Step>> positions) {
for (int i = 0; i < positions.size(); i++) {
Entry<Point, Step> entry = positions.get(i);
Point p = entry.getKey();
int xDist = mousePosition.x - p.x;
int yDist = mousePosition.y - p.y;
int sumSquares = xDist * xDist + yDist * yDist;
if( sumSquares > 15 * 15){
continue;
}
TrainImages trainImages;
if (i == 0) {
trainImages = rr.getEngineImages(train.getEngineType());
} else {
int type = train.getWagon(i - 1);
trainImages = rr.getWagonImages(type);
}
BufferedImage image = (BufferedImage) trainImages.getOverheadImage(entry.getValue().getID());
int x = xDist + 15;
int y = yDist + 15;
Color c = new Color(image.getRGB(x, y), true);
int alpha = c.getAlpha();
if(alpha > 128){
return true;
}
}
return false;
}
public void paintTrain(Graphics g, TrainModel train, TrainPositionOnMap s, TrainImages.Highlight highlight) {
// If the train has been removed, it will be null!
if (train == null) {
return;
}
/*
* XXX HACK !! really our position ought to be defined at all times, but
* this is a workaround until we can fix movement
*/
if (s == null) {
return;
}
List<Entry<Point, Step>> positions = calcPositions(train, s);
if(null != highlight){
paintTrainHighlight(g, train, positions, highlight);
}
paintTrain(g, train, positions);
}
// @SonnyZ
// This code renders the explosion that occurs when 2 trains crash on the
// map
public void paintTrainCrash(Graphics g, TrainPositionOnMap s) {
// check to see if there is a train
// if (s == null) {
// return;
// }
// // Get the image for that frame of the explosion
// Image explosionImage = rr
// .getExplosionImage(s.getFrameCt() - 1);
// // draw the image
// for (int i = 0; i < s.getLength() - 1; i++) {
// Point wagonCenter = new Point(s.getX(i), s.getY(i));
// g.drawImage(explosionImage, wagonCenter.x - 15, wagonCenter.y - 15, null);
//
// }
// // increment the frame count
// s.incrementFramCt();
}
}

/**
* This class draws the overview map.
*
* @author Luke Lindsay
* @author Robert Tuck
*/
final public class ZoomedOutMapRenderer implements MapRenderer {
private final int imageWidth;
private final int imageHeight;
private final int mapWidth;
private final int mapHeight;
private final int mapX;
private final int mapY;
private final ReadOnlyWorld w;
private BufferedImage one2oneImage;
private BufferedImage mapImage;
private final AffineTransform affineTransform;
// private Graphics2D mapGraphics;
private final GraphicsConfiguration defaultConfiguration = GraphicsEnvironment
.getLocalGraphicsEnvironment().getDefaultScreenDevice()
.getDefaultConfiguration();
private boolean isDirty = true;
public static ZoomedOutMapRenderer getInstance(ReadOnlyWorld world,
Dimension maxSize) {
// Work with doubles to avoid rounding errors.
double worldWidth = world.getMapWidth();
double worldHeight = world.getMapHeight();
double scale;
if (worldWidth / worldHeight > maxSize.getWidth() / maxSize.getHeight()) {
scale = maxSize.getWidth() / worldWidth;
} else {
scale = maxSize.getHeight() / worldHeight;
}
double height = scale * worldHeight;
double width = scale * worldWidth;
return new ZoomedOutMapRenderer(world, (int) width, (int) height, 0, 0,
world.getMapWidth(), world.getMapHeight());
}
private ZoomedOutMapRenderer(ReadOnlyWorld world, int width, int height,
int mapX, int mapY, int mapWidth, int mapHeight) {
w = world;
this.mapWidth = mapWidth;
this.mapHeight = mapHeight;
imageHeight = height;
imageWidth = width;
double scalingFactor = ((double) imageHeight) / mapHeight;
affineTransform = AffineTransform.getScaleInstance(scalingFactor,
scalingFactor);
this.mapX = mapX;
this.mapY = mapY;
refresh();
}
public float getScale() {
return (float) imageHeight / (float) mapHeight;
}
public void paintRect(Graphics g, Rectangle visibleRect) {
renderOffScreenImage();
g.drawImage(mapImage, 0, 0, null);
}
private void renderOffScreenImage() {
if (isDirty) {
Graphics2D mapGraphics = mapImage.createGraphics();
mapGraphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
RenderingHints.VALUE_INTERPOLATION_BILINEAR);
mapGraphics.setClip(0, 0, imageWidth, imageHeight);
mapGraphics.clearRect(0, 0, imageWidth, imageHeight);
mapGraphics.drawImage(one2oneImage, affineTransform, null);
isDirty = false;
}
}
private void refreshTile(Point tile) {
FreerailsTile tt = (FreerailsTile) w.getTile(tile.x, tile.y);
if (tt.getTrackPiece().equals(NullTrackPiece.getInstance())) {
int typeNumber = tt.getTerrainTypeID();
TerrainType terrainType = (TerrainType) w.get(SKEY.TERRAIN_TYPES,
typeNumber);
one2oneImage.setRGB(tile.x, tile.y, terrainType.getRGB());
} else {
/* black with alpha of 1 */
one2oneImage.setRGB(tile.x, tile.y, 0xff000000);
}
isDirty = true;
// int scaledX = (tile.x - mapX) * imageWidth / mapWidth;
// int scaledY = (tile.y - mapY) * imageHeight / mapHeight;
// int minx = scaledX < 2 ? 0 : scaledX - 2;
// int miny = scaledY < 2 ? 0 : scaledY - 2;
// int maxx = scaledX > imageWidth - 4 ? imageWidth : scaledX + 4;
// int maxy = scaledY > imageHeight - 4 ? imageHeight : scaledY + 4;
// mapGraphics.setClip(minx, miny, maxx - minx, maxy - miny);
// mapGraphics.clearRect(minx, miny, maxx - minx, maxy - miny);
// mapGraphics.drawImage(one2oneImage, affineTransform, null);
}
/**
* Redraw the whole map onto a new buffer.
*/
private void refresh() {
isDirty = true;
/* free up memory used by the old image */
if (mapImage != null) {
mapImage.flush();
}
if (one2oneImage != null) {
one2oneImage.flush();
}
// if (mapGraphics != null) {
// mapGraphics.dispose();
// }
/* generate a 1:1 map of the terrain layer */
one2oneImage = defaultConfiguration.createCompatibleImage(mapWidth,
mapHeight, Transparency.TRANSLUCENT);
mapImage = defaultConfiguration.createCompatibleImage(imageWidth,
imageHeight, Transparency.OPAQUE);
Point tile = new Point();
for (tile.x = mapX; tile.x < mapWidth + mapX; tile.x++) {
for (tile.y = mapY; tile.y < mapHeight + mapY; tile.y++) {
FreerailsTile tt = (FreerailsTile) w.getTile(tile.x, tile.y);
if (tt.getTrackPiece().equals(NullTrackPiece.getInstance())) {
int typeNumber = tt.getTerrainTypeID();
TerrainType terrainType = (TerrainType) w.get(
SKEY.TERRAIN_TYPES, typeNumber);
one2oneImage.setRGB(tile.x - mapX, tile.y - mapY,
terrainType.getRGB());
} else {
/* black with alpha of 1 */
one2oneImage.setRGB(tile.x - mapX, tile.y - mapY,
0xff000000);
}
}
}
renderOffScreenImage();
}
/*
* @see NewMapView#getMapSizeInPixels()
*/
public Dimension getMapSizeInPixels() {
return new Dimension(imageWidth, imageHeight);
}
public void paintTile(Graphics g, int tileX, int tileY) {
g.drawImage(mapImage, 0, 0, null);
}
public void refreshTile(int x, int y) {
refreshTile(new Point(x, y));
}
public void refreshAll() {
refresh();
}
}

/**
* A JPopupMenu that displays the list of industries that can be built. This
* class contains the code that generates and dispatches a ChangeTileMove when
* the player clicks on the menu.
*
* @author Luke
*
*/
public class BuildIndustryJPopupMenu extends JPopupMenu implements View {
private static final long serialVersionUID = 3689636912575165749L;
private final Point cursorLocation = new Point();
public void setCursorLocation(Point p) {
cursorLocation.x = p.x;
cursorLocation.y = p.y;
}
public void setup(final ModelRoot modelRoot, RenderersRoot vl,
Action closeAction) {
this.removeAll();
final NonNullElements it = new NonNullElements(SKEY.TERRAIN_TYPES,
modelRoot.getWorld());
while (it.next()) {
TerrainType type = (TerrainType) it.getElement();
final Money price = type.getBuildCost();
if (null != price) {
JMenuItem item = new JMenuItem(type.getDisplayName() + " "
+ price);
item.addActionListener(new ActionListener() {
private final int terrainType = it.getIndex();
public void actionPerformed(ActionEvent arg0) {
Move m1 = new ChangeTileMove(modelRoot.getWorld(),
cursorLocation, terrainType);
Transaction t = new AddItemTransaction(
Transaction.Category.INDUSTRIES, terrainType,
1, price.changeSign());
Move m2 = new AddTransactionMove(modelRoot
.getPrincipal(), t);
CompositeMove m3 = new CompositeMove(m1, m2);
MoveStatus ms = modelRoot.doMove(m3);
if (!ms.ok) {
modelRoot.setProperty(
ModelRoot.Property.CURSOR_MESSAGE,
ms.message);
}
}
});
add(item);
}
}
}
}

/**
* The menu that lets you select a track type.
*
* @author Luke Lindsay
*/
final public class BuildMenu extends javax.swing.JMenu {
private static final long serialVersionUID = 3617850859305055542L;
public BuildMenu() {
super();
}
public void setup(ActionRoot actionRoot) {
this.removeAll();
this.setText("Build");
add(actionRoot.getBuildTrainDialogAction());
}
}

/**
* The JFrame that you see while you are playing the game.
*
* @author Luke
*/
public class ClientJFrame extends javax.swing.JFrame {
private static final long serialVersionUID = 3834868100742265142L;
private GUIComponentFactory gUIComponentFactory;
/** Creates new form ClientJFrame. */
public ClientJFrame(GUIComponentFactory gcf) {
setup(gcf);
}
private void setup(GUIComponentFactory gcf) {
this.gUIComponentFactory = gcf;
initComponents();
gUIComponentFactory.createDateJLabel();
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
private void initComponents() {// GEN-BEGIN:initComponents
java.awt.GridBagConstraints gridBagConstraints;
rhsjPanel = new javax.swing.JPanel();
mapOverview = gUIComponentFactory.createOverviewMap();
trainsJTabPane1 = gUIComponentFactory.createTrainsJTabPane();
lhsjPanel = new javax.swing.JPanel();
mainMapView = gUIComponentFactory.createMainMap();
statusjPanel = new javax.swing.JPanel();
datejLabel = gUIComponentFactory.createDateJLabel();
cashjLabel = gUIComponentFactory.createCashJLabel();
jMenuBar1 = new javax.swing.JMenuBar();
gameMenu = gUIComponentFactory.createGameMenu();
buildMenu = gUIComponentFactory.createBuildMenu();
BrokerMenu1 = gUIComponentFactory.createBrokerMenu();
displayMenu = gUIComponentFactory.createDisplayMenu();
reportsMenu = gUIComponentFactory.createReportsMenu();
helpMenu = gUIComponentFactory.createHelpMenu();
getContentPane().setLayout(new java.awt.GridBagLayout());
addWindowListener(new java.awt.event.WindowAdapter() {
@Override
public void windowClosing(java.awt.event.WindowEvent evt) {
exitForm(evt);
}
});
rhsjPanel.setLayout(new java.awt.GridBagLayout());
rhsjPanel.add(mapOverview, new java.awt.GridBagConstraints());
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridy = 3;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
rhsjPanel.add(trainsJTabPane1, gridBagConstraints);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 1;
gridBagConstraints.gridy = 0;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weighty = 1.0;
getContentPane().add(rhsjPanel, gridBagConstraints);
lhsjPanel.setLayout(new java.awt.GridBagLayout());
mainMapView.setAlignmentX(0.0F);
mainMapView.setAlignmentY(0.0F);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 0;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
lhsjPanel.add(mainMapView, gridBagConstraints);
statusjPanel.add(datejLabel);
statusjPanel.add(cashjLabel);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
lhsjPanel.add(statusjPanel, gridBagConstraints);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 0;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
getContentPane().add(lhsjPanel, gridBagConstraints);
gameMenu.setText("Game");
jMenuBar1.add(gameMenu);
buildMenu.setText("Build");
jMenuBar1.add(buildMenu);
BrokerMenu1.setText("Broker");
jMenuBar1.add(BrokerMenu1);
displayMenu.setText("Display");
jMenuBar1.add(displayMenu);
reportsMenu.setText("Reports");
jMenuBar1.add(reportsMenu);
helpMenu.setText("Help");
jMenuBar1.add(helpMenu);
setJMenuBar(jMenuBar1);
pack();
}// GEN-END:initComponents
/** Exit the Application. */
private void exitForm(java.awt.event.WindowEvent evt) {// GEN-FIRST:event_exitForm
System.exit(0);
}// GEN-LAST:event_exitForm
public static void main(String args[]) {
new ClientJFrame(new GUIComponentFactoryTestImpl()).setVisible(true);
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JMenu BrokerMenu1;
private javax.swing.JMenu buildMenu;
private javax.swing.JLabel cashjLabel;
private javax.swing.JLabel datejLabel;
private javax.swing.JMenu displayMenu;
private javax.swing.JMenu gameMenu;
private javax.swing.JMenu helpMenu;
private javax.swing.JMenuBar jMenuBar1;
private javax.swing.JPanel lhsjPanel;
private javax.swing.JScrollPane mainMapView;
private javax.swing.JPanel mapOverview;
private javax.swing.JMenu reportsMenu;
private javax.swing.JPanel rhsjPanel;
private javax.swing.JPanel statusjPanel;
private javax.swing.JTabbedPane trainsJTabPane1;
// End of variables declaration//GEN-END:variables
}

/**
* Provides a method that draws a String showing the average FPS over the last
* complete 5000ms interval.
*
* @author Luke
*
*/
public class FPScounter {
private final double[] fpsValues = new double[400];
private int newFrameCount = 0;
private String newFPSstr = "starting..";
private long lastFrameTime;
private final int fontSize;
private final Color bgColor;
FPScounter() {
this.fontSize = 10;
bgColor = new Color(0, 0, 128);
}
// Display the average number of FPS.
void updateFPSCounter() {
long currentTime = System.nanoTime();
if (newFrameCount == 0) {
lastFrameTime = currentTime;
}
double dt = currentTime - lastFrameTime;
double fps = 1000000000d / dt;
fpsValues[newFrameCount % fpsValues.length] = fps;
newFrameCount++;
int n = fpsValues.length;
if (newFrameCount > fpsValues.length) {
double min = Double.MAX_VALUE;
double max = Double.MIN_VALUE;
double mean = 0;
for (int i = 0; i < fpsValues.length; i++) {
min = Math.min(min, fpsValues[i]);
max = Math.max(max, fpsValues[i]);
mean += fpsValues[i];
}
mean = mean / n;
if (mean > max)
throw new IllegalStateException();
if (mean < min)
throw new IllegalStateException();
double variance = 0;
for (int i = 0; i < fpsValues.length; i++) {
double xMinusU = fpsValues[i] - mean;
variance += xMinusU * xMinusU;
}
variance = variance / n;
if (newFrameCount % 20 == 0) {
StringBuffer sb = new StringBuffer();
sb.append("FPS\n");
sb.append(" n ");
sb.append(n);
sb.append('\n');
sb.append(" \u03BC ");
sb.append(Math.round(mean));
sb.append('\n');
sb.append(" \u03C3 ");
sb.append(Math.round(Math.sqrt(variance)));
sb.append('\n');
sb.append(" min ");
sb.append(Math.round(min));
sb.append('\n');
sb.append(" max ");
sb.append(Math.round(max));
sb.append('\n');
newFPSstr = sb.toString();
}
}
// g.setColor(Color.WHITE);
// g.fillRect(50, 50, 50, 20);
// g.setColor(Color.BLACK);
// g.drawString(newFPSstr, 50, 65);
lastFrameTime = currentTime;
}
void drawFPS(Graphics2D g) {
int rectWidth;
int rectHeight;
int rectX;
int rectY;
int positionX = 50;
int positionY = 70;
Color textColor = Color.WHITE;
String[] lines = newFPSstr.split("\n");
rectWidth = 60;
rectHeight = (int) ((fontSize + 1) * 1.2 * lines.length);
rectY = (int) (positionY - fontSize * 1.2);
rectX = positionX;
g.setColor(bgColor);
g.fillRect(rectX, rectY, rectWidth, rectHeight);
g.setColor(textColor);
// g.setFont(font);
for (String s : lines) {
g.drawString(s, positionX, positionY);
positionY += fontSize * 1.2;
}
}
}

/**
* Defines methods that create the GUI components used by the game.
*
* @author Luke
*/
public interface GUIComponentFactory {
JPanel createOverviewMap();
JTabbedPane createTrainsJTabPane();
JScrollPane createMainMap();
JLabel createCashJLabel();
JLabel createDateJLabel();
JMenu createBuildMenu();
JMenu createReportsMenu();
JMenu createGameMenu();
JMenu createDisplayMenu();
JMenu createHelpMenu();
JMenu createBrokerMenu();
}

/**
* Creates and wires up the GUI components.
*
* @author Luke
*/
public class GUIComponentFactoryImpl implements GUIComponentFactory,
WorldMapListener, WorldListListener {
/** Whether to show certain 'cheat' menus used for testing. */
private static final boolean CHEAT = (System.getProperty("cheat") != null);
private static final Logger logger = Logger
.getLogger(GUIComponentFactoryImpl.class.getName());
private final ActionRoot actionRoot;
private final BuildMenu buildMenu;
private final CashJLabel cashjLabel;
private final ClientJFrame clientJFrame;
private final DateJLabel datejLabel;
private final DialogueBoxController dialogueBoxController;
private JMenu displayMenu;
private JMenu helpMenu;
private JMenu brokerMenu;
private boolean isSetup = false;
private JMenuItem leaderBoardJMenuItem;
private DetailMapRenderer mainMap;
private final JScrollPane mainMapScrollPane1;
private final MapViewJComponentConcrete mapViewJComponent;
private final ModelRootImpl modelRoot;
private JMenuItem networthGraphJMenuItem;
private MapRenderer overviewMap;
private final JPanel overviewMapContainer;
private final Rectangle r = new Rectangle(10, 10, 10, 10);
private JMenu reportsMenu;
private ServerControlModel sc;
private ActionAdapter speedActions;
private JMenuItem stationInfoJMenuItem;
private final StationTypesPopup stationTypesPopup;
private JMenuItem trainListJMenuItem;
private JMenuItem trainOrdersJMenuItem;
private JMenuItem callBrokerJMenuItem;
/**
* This is the panel at the bottom right of the screen.
*/
private final RHSJTabPane trainsJTabPane;
private final UserInputOnMapController userInputOnMapController;
private UserMessageGenerator userMessageGenerator;
private RenderersRoot renderers;
private ReadOnlyWorld world;
public GUIComponentFactoryImpl(ModelRootImpl mr, ActionRoot ar) {
modelRoot = mr;
actionRoot = ar;
userInputOnMapController = new UserInputOnMapController(modelRoot, ar);
buildMenu = new jfreerails.client.top.BuildMenu();
mapViewJComponent = new MapViewJComponentConcrete();
mainMapScrollPane1 = new JScrollPane();
overviewMapContainer = new OverviewMapJComponent(r);
stationTypesPopup = new StationTypesPopup();
MainMapAndOverviewMapMediator mediator = new MainMapAndOverviewMapMediator();
mediator.setup(overviewMapContainer, mainMapScrollPane1.getViewport(),
mapViewJComponent, r);
trainsJTabPane = new RHSJTabPane();
datejLabel = new DateJLabel();
cashjLabel = new CashJLabel();
clientJFrame = new ClientJFrame(this);
dialogueBoxController = new DialogueBoxController(clientJFrame,
modelRoot);
actionRoot.setDialogueBoxController(dialogueBoxController);
modelRoot.addSplitMoveReceiver(new MoveReceiver() {
public void processMove(Move move) {
if (move instanceof ChangeGameSpeedMove) {
ChangeGameSpeedMove speedMove = (ChangeGameSpeedMove) move;
for (Enumeration<Action> actionsEnum = speedActions
.getActions(); actionsEnum.hasMoreElements();) {
Action action = actionsEnum.nextElement();
String actionName = (String) action
.getValue(Action.NAME);
if (actionName.equals(actionRoot.getServerControls()
.getGameSpeedDesc(speedMove.getNewSpeed()))) {
speedActions.setSelectedItem(actionName);
}
break;
}
}
}
});
userMessageGenerator = new UserMessageGenerator(this.modelRoot,
this.actionRoot);
modelRoot.addCompleteMoveReceiver(userMessageGenerator);
}
private void countStations() {
NonNullElements stations = new NonNullElements(KEY.STATIONS, modelRoot
.getWorld(), modelRoot.getPrincipal());
boolean enabled;
if (stations.size() > 0) {
enabled = true;
} else {
enabled = false;
}
this.trainsJTabPane.setStationTabEnabled(enabled);
this.stationInfoJMenuItem.setEnabled(enabled);
}
private void countTrains() {
NonNullElements trains = new NonNullElements(KEY.TRAINS, modelRoot
.getWorld(), modelRoot.getPrincipal());
boolean enabled;
if (trains.size() > 0) {
enabled = true;
} else {
enabled = false;
}
this.trainsJTabPane.setTrainTabEnabled(enabled);
this.trainListJMenuItem.setEnabled(enabled);
this.trainOrdersJMenuItem.setEnabled(enabled);
}
public JMenu createBuildMenu() {
return buildMenu;
}
public JLabel createCashJLabel() {
return cashjLabel;
}
public JFrame createClientJFrame(String title) {
clientJFrame.setTitle(title);
return clientJFrame;
}
public JLabel createDateJLabel() {
return datejLabel;
}
public JMenu createBrokerMenu() {
brokerMenu = new JMenu("Broker");
callBrokerJMenuItem = new JMenuItem("Call Broker");
callBrokerJMenuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dialogueBoxController.showBrokerScreen();
}
});
brokerMenu.add(callBrokerJMenuItem);
return brokerMenu;
}
public JMenu createDisplayMenu() {
displayMenu = new JMenu("Display");
displayMenu.setMnemonic(68);
trainOrdersJMenuItem = new JMenuItem("Train Orders");
trainOrdersJMenuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dialogueBoxController.showTrainOrders();
}
});
stationInfoJMenuItem = new JMenuItem("Station Info");
stationInfoJMenuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dialogueBoxController.showStationInfo(0);
}
});
trainListJMenuItem = new JMenuItem("Train List");
trainListJMenuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dialogueBoxController.showTrainList();
}
});
displayMenu.add(trainOrdersJMenuItem);
displayMenu.add(stationInfoJMenuItem);
displayMenu.add(trainListJMenuItem);
displayMenu.addSeparator();
// Add menu items to control what gets displayed on the map.
final JCheckBoxMenuItem showCargoMenuItem = new JCheckBoxMenuItem(
"Show cargo at stations", true);
displayMenu.add(showCargoMenuItem);
showCargoMenuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
modelRoot.setProperty(
ModelRoot.Property.SHOW_CARGO_AT_STATIONS, new Boolean(
showCargoMenuItem.isSelected()));
mapViewJComponent.refreshAll();
}
});
final JCheckBoxMenuItem showStationNamesMenuItem = new JCheckBoxMenuItem(
"Show station names", true);
displayMenu.add(showStationNamesMenuItem);
showStationNamesMenuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
modelRoot.setProperty(ModelRoot.Property.SHOW_STATION_NAMES,
new Boolean(showStationNamesMenuItem.isSelected()));
mapViewJComponent.refreshAll();
}
});
final JCheckBoxMenuItem showStationBordersMenuItem = new JCheckBoxMenuItem(
"Show sphere-of-influence around stations", true);
displayMenu.add(showStationBordersMenuItem);
showStationBordersMenuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
modelRoot.setProperty(ModelRoot.Property.SHOW_STATION_BORDERS,
new Boolean(showStationBordersMenuItem.isSelected()));
mapViewJComponent.refreshAll();
}
});
final JCheckBoxMenuItem playSoundsMenuItem = new JCheckBoxMenuItem(
"Play sounds", true);
displayMenu.add(playSoundsMenuItem);
playSoundsMenuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
modelRoot.setProperty(ModelRoot.Property.PLAY_SOUNDS,
new Boolean(playSoundsMenuItem.isSelected()));
}
});
;
boolean showFps = Boolean.parseBoolean(System.getProperty("SHOWFPS"));
final JCheckBoxMenuItem showFPSMenuItem = new JCheckBoxMenuItem(
"Show FPS stats", showFps);
displayMenu.add(showFPSMenuItem);
showFPSMenuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String newValue = String.valueOf(showFPSMenuItem.isSelected());
System.setProperty("SHOWFPS", newValue);
}
});
return displayMenu;
}
public JMenu createGameMenu() {
sc = actionRoot.getServerControls();
JMenu gameMenu = new JMenu("Game");
gameMenu.setMnemonic(71);
JMenuItem quitJMenuItem = new JMenuItem("Exit Game");
quitJMenuItem.setMnemonic(88);
quitJMenuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
System.exit(0);
}
});
final JMenu newGameJMenu = new JMenu(sc.getNewGameAction());
newGameJMenu.addMenuListener(new MenuListener() {
public void menuCanceled(MenuEvent e) {
}
public void menuDeselected(MenuEvent e) {
}
public void menuSelected(MenuEvent e) {
newGameJMenu.removeAll();
Enumeration<Action> actions = sc.getMapNames().getActions();
while (actions.hasMoreElements()) {
JMenuItem mi = new JMenuItem(actions.nextElement());
newGameJMenu.add(mi);
}
}
});
JMenuItem saveGameJMenuItem = new JMenuItem(sc.getSaveGameAction());
JMenuItem loadGameJMenuItem = new JMenuItem(sc.getLoadGameAction());
// Fix bug 1102806 Newspaper does nothing, so hide it.
// JMenuItem newspaperJMenuItem = new JMenuItem("Newspaper");
// newspaperJMenuItem.setMnemonic(78);
// newspaperJMenuItem.addActionListener(new ActionListener() {
// public void actionPerformed(ActionEvent e) {
// dialogueBoxController.showNewspaper("Headline");
// //glassPanel.setVisible(true);
// }
// });
// Set up the game speed sub-menu.
JMenu gameSpeedSubMenu = new JMenu("Game Speed");
ButtonGroup group = new ButtonGroup();
speedActions = sc.getSetTargetTickPerSecondActions();
Enumeration<MappedButtonModel> buttonModels = speedActions
.getButtonModels();
Enumeration<Action> actions = speedActions.getActions();
while (buttonModels.hasMoreElements()) {
JRadioButtonMenuItem mi = new JRadioButtonMenuItem(actions
.nextElement());
mi.setModel(buttonModels.nextElement());
group.add(mi);
gameSpeedSubMenu.add(mi);
}
gameMenu.add(newGameJMenu);
gameMenu.addSeparator();
gameMenu.add(loadGameJMenuItem);
gameMenu.add(saveGameJMenuItem);
gameMenu.addSeparator();
gameMenu.add(gameSpeedSubMenu);
// gameMenu.add(newspaperJMenuItem);
gameMenu.addSeparator();
gameMenu.add(quitJMenuItem);
if (CHEAT) {
/** For testing. */
final ActionListener build200trains = new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
WorldIterator wi = new NonNullElements(KEY.STATIONS,
modelRoot.getWorld(), modelRoot.getPrincipal());
if (wi.next()) {
Random randy = new Random();
StationModel station = (StationModel) wi.getElement();
ImList<PlannedTrain> before = station
.getProduction();
int numberOfEngineTypes = modelRoot.getWorld().size(
SKEY.ENGINE_TYPES) - 1;
int numberOfcargoTypes = modelRoot.getWorld().size(
SKEY.CARGO_TYPES) - 1;
PlannedTrain[] temp = new PlannedTrain[200];
for (int i = 0; i < temp.length; i++) {
int engineType = randy.nextInt(numberOfEngineTypes);
int[] wagonTypes = new int[] {
randy.nextInt(numberOfcargoTypes),
randy.nextInt(numberOfcargoTypes),
randy.nextInt(numberOfcargoTypes) };
PlannedTrain plannedTrain = new PlannedTrain(engineType, wagonTypes);
temp[i] = plannedTrain;
}
ImList<PlannedTrain> after = new ImList<PlannedTrain>(temp);
Move m = new ChangeProductionAtEngineShopMove(before,
after, wi.getIndex(), modelRoot.getPrincipal());
modelRoot.doMove(m);
}
}
};
JMenuItem build200TrainsMenuItem = new JMenuItem(
"Build 200 trains!");
build200TrainsMenuItem.addActionListener(build200trains);
gameMenu.add(build200TrainsMenuItem);
}
return gameMenu;
}
public JMenu createHelpMenu() {
helpMenu = new javax.swing.JMenu("Help");
JMenuItem about = new JMenuItem("About");
about.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
dialogueBoxController.showAbout();
}
});
JMenuItem how2play = new JMenuItem("Getting started");
how2play.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
dialogueBoxController.showHow2Play();
}
});
JMenuItem showControls = new JMenuItem("Show game controls");
showControls.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
dialogueBoxController.showGameControls();
}
});
JMenuItem showJavaProperties = new JMenuItem("Show Java Properties");
showJavaProperties
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
dialogueBoxController.showJavaProperties();
}
});
JMenuItem showReportBug = new JMenuItem("Report Bug");
showReportBug.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
dialogueBoxController.showReportBug();
}
});
helpMenu.add(showControls);
helpMenu.add(how2play);
helpMenu.add(showJavaProperties);
helpMenu.add(showReportBug);
helpMenu.add(about);
return helpMenu;
}
public JScrollPane createMainMap() {
return mainMapScrollPane1;
}
public JPanel createOverviewMap() {
return overviewMapContainer;
}
public JMenu createReportsMenu() {
reportsMenu = new javax.swing.JMenu("Reports");
JMenuItem incomeStatementJMenuItem = new JMenuItem("Income Statement");
incomeStatementJMenuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dialogueBoxController.showIncomeStatement();
}
});
JMenuItem balanceSheetJMenuItem = new JMenuItem("Balance Sheet");
balanceSheetJMenuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dialogueBoxController.showBalanceSheet();
}
});
leaderBoardJMenuItem = new JMenuItem("Leaderboard");
leaderBoardJMenuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dialogueBoxController.showLeaderBoard();
}
});
networthGraphJMenuItem = new JMenuItem("Networth Graph");
networthGraphJMenuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dialogueBoxController.showNetworthGraph();
}
});
reportsMenu.add(balanceSheetJMenuItem);
reportsMenu.add(incomeStatementJMenuItem);
reportsMenu.add(leaderBoardJMenuItem);
reportsMenu.add(networthGraphJMenuItem);
return reportsMenu;
}
public JTabbedPane createTrainsJTabPane() {
return trainsJTabPane;
}
public BuildTrackController getBuildTrackController() {
return mainMap.getBuildTrackController();
}
public boolean isSetup() {
return isSetup;
}
public void itemAdded(KEY key, int index, FreerailsPrincipal principal) {
boolean rightPrincipal = principal
.equals(this.modelRoot.getPrincipal());
if (KEY.TRAINS == key && rightPrincipal) {
countTrains();
} else if (KEY.STATIONS == key && rightPrincipal) {
countStations();
}
}
public void itemRemoved(KEY key, int index, FreerailsPrincipal principal) {
// do nothing
}
public void listUpdated(KEY key, int index, FreerailsPrincipal principal) {
boolean rightPrincipal = principal
.equals(this.modelRoot.getPrincipal());
if (KEY.TRAINS == key && rightPrincipal) {
countTrains();
} else if (KEY.STATIONS == key && rightPrincipal) {
countStations();
}
}
/**
* Called when a new game is started or a game is loaded.
* <p>
* <b>Be extremely careful with the references of objects allocated in this
* method to avoid memory leaks - see bug 967677 (OutOfMemoryError after
* starting several new games). </b>
* </p>
*/
public void setup(RenderersRoot vl, ReadOnlyWorld w) throws IOException {
/*
* Set the cursor position. The initial cursor position is 0,0. However,
* if a game is loaded or a new game is started and the map size is the
* same as the last map size, then the cursor should take the position
* it had on the last map.
*/
ImPoint cursorPosition = new ImPoint(0, 0);
if (null != world) {
if (w.getMapWidth() == world.getMapWidth()
&& w.getMapHeight() == world.getMapHeight()) {
cursorPosition = (ImPoint) modelRoot
.getProperty(ModelRoot.Property.CURSOR_POSITION);
}
}
renderers = vl;
world = w;
modelRoot.addMapListener(this);
modelRoot.addListListener(this);
if (!vl.validate(world)) {
throw new IllegalArgumentException("The specified"
+ " RenderersRoot are not compatible with the clients"
+ "world!");
}
// create the main and overview maps
mainMap = new DetailMapRenderer(world, renderers, modelRoot);
TrainRenderer trainRenderer = mainMap.getTrainRenderer();
Dimension maxSize = new Dimension(200, 200);
overviewMap = ZoomedOutMapRenderer.getInstance(world, maxSize);
stationTypesPopup.setup(modelRoot, actionRoot, mainMap
.getStationRadius());
mapViewJComponent
.setup(mainMap, modelRoot, renderers);
// setup the the main and overview map JComponents
dialogueBoxController.setDefaultFocusOwner(mapViewJComponent);
userInputOnMapController.setup(mapViewJComponent, actionRoot
.getTrackMoveProducer(), stationTypesPopup, this.modelRoot,
dialogueBoxController, mapViewJComponent.getMapCursor(),
getBuildTrackController(), trainRenderer);
buildMenu.setup(actionRoot);
mainMapScrollPane1.setViewportView(this.mapViewJComponent);
((OverviewMapJComponent) overviewMapContainer).setup(overviewMap);
datejLabel.setup(modelRoot, vl, null);
cashjLabel.setup(modelRoot, vl, null);
trainsJTabPane.setup(actionRoot, vl, modelRoot);
dialogueBoxController.setup(modelRoot, vl);
StationPlacementCursor.wireUp(actionRoot, mainMap.getStationRadius(),
mapViewJComponent);
int gameSpeed = ((GameSpeed) world.get(ITEM.GAME_SPEED)).getSpeed();
/* Set the selected game speed radio button. */
String actionName = actionRoot.getServerControls().getGameSpeedDesc(
gameSpeed);
speedActions.setSelectedItem(actionName);
userMessageGenerator.logSpeed();
/*
* Count stations and trains to determine if we need to display the
* station and train menu items and tabs.3
*/
countStations();
countTrains();
String name = modelRoot.getPrincipal().getName();
String serverDetails = (String) modelRoot
.getProperty(ModelRoot.Property.SERVER);
String frameTitle;
if (serverDetails.equals(LocalConnection.SERVER_IN_SAME_JVM)) {
frameTitle = name + " - Freerails";
} else {
frameTitle = name + " - " + serverDetails + " - Freerails";
}
clientJFrame.setTitle(frameTitle);
isSetup = true;
modelRoot.setProperty(ModelRoot.Property.CURSOR_POSITION,
cursorPosition);
mapViewJComponent.requestFocus();
}
/**
* Listens for changes on the map, for instance when track is built, and
* refreshes the map views.
*/
public void tilesChanged(Rectangle tilesChanged) {
logger.fine("TilesChanged = " + tilesChanged);
// If lots of tiles have changed, do a complete refresh.
int size = tilesChanged.width * tilesChanged.height;
if (size > 100) {
mainMap.refreshAll();
overviewMap.refreshAll();
} else {
Point tile = new Point();
// Fix for bug 967673 (Crash when building track close to edge of
// map).
Rectangle mapRect = new Rectangle(0, 0, world.getMapWidth(), world
.getMapHeight());
tilesChanged = tilesChanged.intersection(mapRect);
for (tile.x = tilesChanged.x; tile.x < (tilesChanged.x + tilesChanged.width); tile.x++) {
for (tile.y = tilesChanged.y; tile.y < (tilesChanged.y + tilesChanged.height); tile.y++) {
mainMap.refreshTile(tile.x, tile.y);
overviewMap.refreshTile(tile.x, tile.y);
}
}
}
}
}

/**
* Implementation of GUIComponentFactory that returns 'blank' components - used
* for testing the layout of ClientJFrame.
*
* @author Luke
*/
public class GUIComponentFactoryTestImpl implements GUIComponentFactory {
private final JLabel datejLabel;
private final JLabel cashjLabel;
private final JTabbedPane trainsJPanel;
private final JMenu displayMenu;
private final JScrollPane mainMapView;
private final JMenu buildMenu;
private final JMenu gameMenu;
private final JPanel mapOverview;
private final JMenu helpMenu;
private final JLabel messageJLabel;
private final JMenu brokerMenu;
/** Creates a new instance of GUIComponentFactoryTestImpl. */
public GUIComponentFactoryTestImpl() {
JPanel mainmapjPanel;
trainsJPanel = new JTabbedPane();
datejLabel = new JLabel();
mapOverview = new JPanel();
cashjLabel = new JLabel();
mainMapView = new JScrollPane();
mainmapjPanel = new JPanel();
messageJLabel = new JLabel();
gameMenu = new JMenu();
buildMenu = new JMenu();
displayMenu = new JMenu();
helpMenu = new JMenu();
brokerMenu = new JMenu();
trainsJPanel.setBackground(new java.awt.Color(255, 51, 51));
datejLabel.setText("Jun, 1840");
mapOverview.setBackground(new java.awt.Color(0, 204, 255));
mapOverview.setPreferredSize(new java.awt.Dimension(100, 100));
cashjLabel.setText("$100,000");
mainmapjPanel.setBackground(new java.awt.Color(153, 244, 51));
mainMapView.setViewportView(mainmapjPanel);
messageJLabel.setText("message");
}
public JMenu createReportsMenu() {
return new JMenu("Reports");
}
public JMenu createBuildMenu() {
return buildMenu;
}
public JLabel createCashJLabel() {
return cashjLabel;
}
public JLabel createDateJLabel() {
return datejLabel;
}
public JMenu createDisplayMenu() {
return displayMenu;
}
public JMenu createGameMenu() {
return gameMenu;
}
public JMenu createHelpMenu() {
return helpMenu;
}
public JScrollPane createMainMap() {
return mainMapView;
}
public JPanel createOverviewMap() {
return mapOverview;
}
public JTabbedPane createTrainsJTabPane() {
return trainsJPanel;
}
public JMenu createBrokerMenu() {
return brokerMenu;
}
}

/**
* This thread updates the GUI Client window.
*
* @author Luke
*/
final public class GameLoop implements Runnable {
private static final Logger logger = Logger.getLogger(GameLoop.class
.getName());
private final static boolean LIMIT_FRAME_RATE = false;
private boolean gameNotDone = false;
private final ScreenHandler screenHandler;
private final static int TARGET_FPS = 40;
private FPScounter fPScounter;
private long frameStartTime;
private final GameModel[] model;
private final Integer loopMonitor = new Integer(0);
public GameLoop(ScreenHandler s) {
screenHandler = s;
model = new GameModel[0];
}
public GameLoop(ScreenHandler s, GameModel[] gm) {
screenHandler = s;
model = gm;
if (null == model) {
throw new NullPointerException();
}
}
public void run() {
try {
SynchronizedEventQueue.use();
RepaintManagerForActiveRendering.addJFrame(screenHandler.frame);
RepaintManagerForActiveRendering.setAsCurrentManager();
if (!screenHandler.isInUse()) {
screenHandler.apply();
}
gameNotDone = true;
fPScounter = new FPScounter();
/*
* Reduce this threads priority to avoid starvation of the input
* thread on Windows.
*/
try {
Thread.currentThread().setPriority(Thread.NORM_PRIORITY - 1);
} catch (SecurityException e) {
logger.warning("Couldn't lower priority of redraw thread");
}
while (true) {
// stats.record();
frameStartTime = System.currentTimeMillis();
/*
* Flush all redraws in the underlying toolkit. This reduces X11
* lag when there isn't much happening, but is expensive under
* Windows
*/
Toolkit.getDefaultToolkit().sync();
synchronized (SynchronizedEventQueue.MUTEX) {
if (!gameNotDone) {
SynchronizedEventQueue.MUTEX.notify();
break;
}
for (int i = 0; i < model.length; i++) {
model[i].update();
}
if (!screenHandler.isMinimised()) {
if (screenHandler.isInUse()) {
boolean contentsRestored = false;
do {
Graphics g = screenHandler.getDrawGraphics();
try {
screenHandler.frame.paintComponents(g);
boolean showFps = Boolean
.parseBoolean(System
.getProperty("SHOWFPS"));
if (showFps) {
fPScounter.drawFPS((Graphics2D) g);
}
} catch (RuntimeException re) {
/*
* We are not expecting a RuntimeException
* here. If something goes wrong, lets kill
* the game straight away to avoid
* hard-to-track-down bugs.
*/
ReportBugTextGenerator
.unexpectedException(re);
} finally {
g.dispose();
}
contentsRestored = screenHandler
.contentsRestored();
} while (contentsRestored);
screenHandler.swapScreens();
fPScounter.updateFPSCounter();
}
}
}
if (screenHandler.isMinimised()) {
try {
// The window is minimised so we don't need to keep
// updating.
Thread.sleep(200);
} catch (Exception e) {
// do nothing.
}
} else if (LIMIT_FRAME_RATE) {
long deltatime = System.currentTimeMillis()
- frameStartTime;
while (deltatime < (1000 / TARGET_FPS)) {
try {
long sleeptime = (1000 / TARGET_FPS) - deltatime;
Thread.sleep(sleeptime);
} catch (Exception e) {
e.printStackTrace();
}
deltatime = System.currentTimeMillis() - frameStartTime;
}
}
// remove all events from a event queue (max 5ms)
long startEventWaitTime = System.currentTimeMillis() + 4;
while (SynchronizedEventQueue.getInstance().peekEvent() != null) {
// we have events
Thread.yield();
if (startEventWaitTime < System.currentTimeMillis()) {
break;
}
}
}
/* signal that we are done */
synchronized (loopMonitor) {
loopMonitor.notify();
}
} catch (Exception e) {
ReportBugTextGenerator.unexpectedException(e);
}
}
}

/**
* Simple implementation of TileRendererList, for testing purposes only.
*
* @author Luke
*
*/
public class QuickRGBTileRendererList implements TileRendererList {
private final int[] rgbValues;
private final Image[] images;
private final HashMap<Integer, Integer> rgb2index = new HashMap<Integer, Integer>();
private final SimpleTileRenderer simpleTileRenderer = new SimpleTileRenderer();
private static final java.awt.GraphicsConfiguration defaultConfiguration = java.awt.GraphicsEnvironment
.getLocalGraphicsEnvironment().getDefaultScreenDevice()
.getDefaultConfiguration();
public QuickRGBTileRendererList(ReadOnlyWorld w) {
int numberOfTerrainTypes = w.size(SKEY.TERRAIN_TYPES);
rgbValues = new int[numberOfTerrainTypes];
images = new Image[numberOfTerrainTypes];
for (int i = 0; i < numberOfTerrainTypes; i++) {
TerrainType t = (TerrainType) w.get(SKEY.TERRAIN_TYPES, i);
rgbValues[i] = t.getRGB();
images[i] = createImageFor(t);
rgb2index.put(new Integer(t.getRGB()), new Integer(i));
}
}
public static Image createImageFor(TerrainType t) {
Image image = defaultConfiguration.createCompatibleImage(
Constants.TILE_SIZE, Constants.TILE_SIZE);
Color c = new Color(t.getRGB());
Graphics g = image.getGraphics();
g.setColor(c);
g.fillRect(0, 0, Constants.TILE_SIZE, Constants.TILE_SIZE);
g.dispose();
return image;
}
public TileRenderer getTileViewWithNumber(int i) {
throw new UnsupportedOperationException();
}
public TileRenderer getTileViewWithRGBValue(int rgb) {
Integer i = rgb2index.get(new Integer(rgb));
this.simpleTileRenderer.setImage(images[i.intValue()]);
return simpleTileRenderer;
}
public boolean validate(ReadOnlyWorld world) {
return true;
}
class SimpleTileRenderer implements TileRenderer {
Image i;
public SimpleTileRenderer() {
}
public void setImage(Image i) {
this.i = i;
}
public Image getDefaultIcon() {
return i;
}
public void renderTile(Graphics g, int renderX, int renderY, int mapX,
int mapY, ReadOnlyWorld w) {
g.drawImage(i, renderX, renderY, null);
}
public void dumpImages(ImageManager imageManager) {
// TODO Auto-generated method stub
throw new UnsupportedOperationException();
}
}
}

/**
* Implementation of RenderersRoot whose constructor loads graphics and provides
* feed back using a FreerailsProgressMonitor.
*
* @author Luke
*/
public class RenderersRootImpl implements RenderersRoot {
private static final Logger logger = Logger.getLogger(RenderersRootImpl.class
.getName());
private final TileRendererList tiles;
private final TrackPieceRendererList trackPieceViewList;
private final ImageManager imageManager;
private final ArrayList<TrainImages> wagonImages = new ArrayList<TrainImages>();
private final ArrayList<TrainImages> engineImages = new ArrayList<TrainImages>();
public RenderersRootImpl(ReadOnlyWorld w, FreerailsProgressMonitor pm)
throws IOException {
URL out = RenderersRootImpl.class.getResource("/experimental");
imageManager = new ImageManagerImpl("/jfreerails/client/graphics/", out
.getPath());
tiles = loadNewTileViewList(w, pm);
trackPieceViewList = loadTrackViews(w, pm);
//rr = new OldTrainImages(w, imageManager, pm);
loadTrainImages(w, pm);
preloadSounds(pm);
}
private void loadTrainImages(ReadOnlyWorld w, FreerailsProgressMonitor pm)
throws IOException {
// Setup progress monitor..
final int numberOfWagonTypes = w.size(SKEY.CARGO_TYPES);
final int numberOfEngineTypes = w.size(SKEY.ENGINE_TYPES);
pm.nextStep(numberOfWagonTypes + numberOfEngineTypes);
int progress = 0;
pm.setValue(progress);
//Load wagon images.
for (int i = 0; i < numberOfWagonTypes; i++) {
CargoType cargoType = (CargoType) w.get(SKEY.CARGO_TYPES, i);
String name = cargoType.getName();
TrainImages ti = new TrainImages(imageManager, name);
wagonImages.add(ti);
pm.setValue(++progress);
}
//Load engine images
for (int i = 0; i < numberOfEngineTypes; i++) {
EngineType engineType = (EngineType) w.get(SKEY.ENGINE_TYPES, i);
String engineTypeName = engineType
.getEngineTypeName();
TrainImages ti = new TrainImages(imageManager, engineTypeName);
engineImages.add(ti);
pm.setValue(++progress);
}
}
private void preloadSounds(FreerailsProgressMonitor pm) {
// Pre-load sounds..
String[] soundsFiles = { "/jfreerails/client/sounds/buildtrack.wav",
"/jfreerails/client/sounds/cash.wav",
"/jfreerails/client/sounds/removetrack.wav",
"/jfreerails/client/sounds/whistle.wav" };
pm.nextStep(soundsFiles.length);
SoundManager sm = SoundManager.getSoundManager();
for (int i = 0; i < soundsFiles.length; i++) {
try {
sm.addClip(soundsFiles[i]);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (UnsupportedAudioFileException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (LineUnavailableException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
pm.setValue(i + 1);
}
}
private TrackPieceRendererList loadTrackViews(ReadOnlyWorld w,
FreerailsProgressMonitor pm) throws IOException {
return new TrackPieceRendererList(w, imageManager, pm);
}
private TileRendererList loadNewTileViewList(ReadOnlyWorld w,
FreerailsProgressMonitor pm) throws IOException {
ArrayList<TileRenderer> tileRenderers = new ArrayList<TileRenderer>();
// Setup progress monitor..
int numberOfTypes = w.size(SKEY.TERRAIN_TYPES);
pm.nextStep(numberOfTypes);
int progress = 0;
pm.setValue(progress);
for (int i = 0; i < numberOfTypes; i++) {
TerrainType t = (TerrainType) w.get(SKEY.TERRAIN_TYPES, i);
int[] typesTreatedAsTheSame = new int[] { i };
TileRenderer tr = null;
pm.setValue(++progress);
try {
// XXX hack to make rivers flow into ocean and habours & occean
// treat habours as the same type.
TerrainType.Category thisTerrainCategory = t.getCategory();
if (thisTerrainCategory.equals(TerrainType.Category.River)
|| thisTerrainCategory
.equals(TerrainType.Category.Ocean)) {
// Count number of types with category "water"
int count = 0;
for (int j = 0; j < numberOfTypes; j++) {
TerrainType t2 = (TerrainType) w.get(
SKEY.TERRAIN_TYPES, j);
TerrainType.Category terrainCategory = t2.getCategory();
if (terrainCategory.equals(TerrainType.Category.Ocean)
|| terrainCategory.equals(thisTerrainCategory)) {
count++;
}
}
typesTreatedAsTheSame = new int[count];
count = 0;
for (int j = 0; j < numberOfTypes; j++) {
TerrainType t2 = (TerrainType) w.get(
SKEY.TERRAIN_TYPES, j);
TerrainType.Category terrainCategory = t2.getCategory();
if (terrainCategory.equals(TerrainType.Category.Ocean)
|| terrainCategory.equals(thisTerrainCategory)) {
typesTreatedAsTheSame[count] = j;
count++;
}
}
}
tr = new RiverStyleTileRenderer(imageManager,
typesTreatedAsTheSame, t);
tileRenderers.add(tr);
continue;
} catch (IOException io) {
}
try {
tr = new ForestStyleTileRenderer(imageManager,
typesTreatedAsTheSame, t);
tileRenderers.add(tr);
continue;
} catch (IOException io) {
}
try {
tr = new ChequeredTileRenderer(imageManager,
typesTreatedAsTheSame, t);
tileRenderers.add(tr);
continue;
} catch (IOException io) {
}
try {
tr = new StandardTileRenderer(imageManager,
typesTreatedAsTheSame, t);
tileRenderers.add(tr);
continue;
} catch (IOException io) {
// If the image is missing, we generate it.
logger
.warning("No tile renderer for "
+ t.getTerrainTypeName());
String filename = StandardTileRenderer.generateFilename(t
.getTerrainTypeName());
Image image = QuickRGBTileRendererList.createImageFor(t);
imageManager.setImage(filename, image);
// generatedImages.setImage(filename, image);
try {
tr = new StandardTileRenderer(imageManager,
typesTreatedAsTheSame, t);
tileRenderers.add(tr);
continue;
} catch (IOException io2) {
io2.printStackTrace();
throw new IllegalStateException();
}
}
}
// XXXX add special tile renderer for habours
TileRenderer oceanTileRenderer = null;
for (int j = 0; j < numberOfTypes; j++) {
TerrainType t2 = (TerrainType) w.get(SKEY.TERRAIN_TYPES, j);
String terrainName = t2.getTerrainTypeName();
if (terrainName.equalsIgnoreCase("Ocean")) {
oceanTileRenderer = tileRenderers.get(j);
break;
}
}
for (int j = 0; j < numberOfTypes; j++) {
TerrainType t2 = (TerrainType) w.get(SKEY.TERRAIN_TYPES, j);
String terrainName = t2.getTerrainTypeName();
if (terrainName.equalsIgnoreCase("Harbour")) {
TerrainType t = (TerrainType) w.get(SKEY.TERRAIN_TYPES, j);
TileRenderer tr = new SpecialTileRenderer(imageManager,
new int[] { j }, t, oceanTileRenderer);
tileRenderers.set(j, tr);
break;
}
}
return new TileRendererListImpl(tileRenderers);
}
public TileRendererList getTileViewList() {
return this.tiles;
}
public TrackPieceRendererList getTrackPieceViewList() {
return this.trackPieceViewList;
}
public boolean validate(ReadOnlyWorld w) {
boolean okSoFar = true;
if (!this.tiles.validate(w)) {
okSoFar = false;
}
if (!this.trackPieceViewList.validate(w)) {
okSoFar = false;
}
return okSoFar;
}
// public OldTrainImages getTrainImages() {
// return rr;
// }
public ImageManager getImageManager() {
return imageManager;
}
public Image getImage(String relativeFilename) throws IOException {
return imageManager.getImage(relativeFilename);
}
public TileRenderer getTileViewWithNumber(int i) {
return tiles.getTileViewWithNumber(i);
}
public TrackPieceRenderer getTrackPieceView(int i) {
return trackPieceViewList.getTrackPieceView(i);
}
public TrainImages getWagonImages(int type) {
return wagonImages.get(type);
}
public TrainImages getEngineImages(int type) {
return engineImages.get(type);
}
public Image getScaledImage(String relativeFilename, int height) throws IOException {
return imageManager.getScaledImage(relativeFilename, height);
}
}

/**
* This JPopupMenu displays the list of station types that are available and
* builds the type that is selected.
*
* @author Luke Lindsay 08-Nov-2002
*
*/
public class StationTypesPopup extends JPopupMenu {
private static final long serialVersionUID = 3258415040658093364L;
private Point tileToBuildStationOn;
private StationRadiusRenderer stationRadiusRenderer;
private PopupMenuListener popupMenuListener;
private StationBuildModel stationBuildModel;
private ModelRoot modelRoot;
public StationTypesPopup() {
}
public boolean canBuiltStationHere(Point p) {
stationBuildModel.getStationBuildAction().putValue(
StationBuildModel.StationBuildAction.STATION_POSITION_KEY, p);
FreerailsTile tile = (FreerailsTile) modelRoot.getWorld().getTile(p.x,
p.y);
return tile.hasTrack();
}
private class StationBuildMenuItem extends JMenuItem {
private static final long serialVersionUID = 3256721792751120946L;
@Override
public void configurePropertiesFromAction(Action a) {
super.configurePropertiesFromAction(a);
}
}
public void setup(ModelRoot mr, ActionRoot actionRoot,
StationRadiusRenderer srr) {
modelRoot = mr;
stationBuildModel = actionRoot.getStationBuildModel();
stationRadiusRenderer = srr;
this.removeAll();
this.removePopupMenuListener(popupMenuListener);
popupMenuListener = new PopupMenuListener() {
public void popupMenuCanceled(PopupMenuEvent e) {
}
public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {
stationRadiusRenderer.hide();
stationBuildModel.getStationCancelAction().actionPerformed(
new ActionEvent(StationTypesPopup.this,
ActionEvent.ACTION_PERFORMED, ""));
}
public void popupMenuWillBecomeVisible(PopupMenuEvent e) {
stationRadiusRenderer.setPosition(tileToBuildStationOn.x,
tileToBuildStationOn.y);
stationBuildModel
.getStationBuildAction()
.putValue(
StationBuildModel.StationBuildAction.STATION_POSITION_KEY,
tileToBuildStationOn);
}
};
this.addPopupMenuListener(popupMenuListener);
final Action[] stationChooseActions = stationBuildModel
.getStationChooseActions();
for (int i = 0; i < stationChooseActions.length; i++) {
final StationBuildMenuItem rbMenuItem = new StationBuildMenuItem();
final int index = i;
rbMenuItem.configurePropertiesFromAction(stationChooseActions[i]);
rbMenuItem.setIcon(null);
// Show the relevant station radius when the station type's
// menu item gets focus.
rbMenuItem.addChangeListener(new ChangeListener() {
private boolean armed = false;
public void stateChanged(ChangeEvent e) {
if (rbMenuItem.isArmed() && (rbMenuItem.isArmed() != armed)) {
stationChooseActions[index]
.actionPerformed(new ActionEvent(rbMenuItem,
ActionEvent.ACTION_PERFORMED, ""));
}
armed = rbMenuItem.isArmed();
}
});
rbMenuItem.addActionListener(stationBuildModel
.getStationBuildAction());
add(rbMenuItem);
}
stationBuildModel.getStationBuildAction().addPropertyChangeListener(
new PropertyChangeListener() {
public void propertyChange(PropertyChangeEvent e) {
if (e
.getPropertyName()
.equals(
StationBuildModel.StationBuildAction.STATION_RADIUS_KEY)) {
int newRadius = ((Integer) e.getNewValue())
.intValue();
stationRadiusRenderer.setRadius(newRadius);
}
if (stationBuildModel.getStationBuildAction()
.isEnabled()) {
stationRadiusRenderer.show();
} else {
stationRadiusRenderer.hide();
}
}
});
}
public void showMenu(Component invoker, int x, int y, Point tile) {
tileToBuildStationOn = tile;
super.show(invoker, x, y);
}
@Override
public void setVisible(boolean b) {
// If this popup is visible, we don't want the station's position to
// follow the mouse.
stationBuildModel.setPositionFollowsMouse(!b);
super.setVisible(b);
}
}

/**
* This event queue is synchronized on the MUTEX. This lets one control when
* events can be dispatched.
*
* Note, changed to be a singleton to get it working on pre 1.4.2 VMs.
*
* @author Luke
*
*/
final public class SynchronizedEventQueue extends EventQueue {
public static final Object MUTEX = new Object();
private static final SynchronizedEventQueue instance = new SynchronizedEventQueue();
private static boolean alreadyInUse = false;
/** Enforce singleton property. */
private SynchronizedEventQueue() {
}
public static synchronized void use() {
if (!alreadyInUse) {
/* set up the synchronized event queue */
EventQueue eventQueue = Toolkit.getDefaultToolkit()
.getSystemEventQueue();
eventQueue.push(instance);
alreadyInUse = true;
}
}
@Override
protected void dispatchEvent(AWTEvent aEvent) {
synchronized (MUTEX) {
try {
super.dispatchEvent(aEvent);
} catch (Exception e) {
/*
* If something goes wrong, lets kill the game straight away to
* avoid hard-to-track-down bugs.
*/
ReportBugTextGenerator.unexpectedException(e);
}
}
}
public static SynchronizedEventQueue getInstance() {
return instance;
}
}

/**
* Handles key presses and mouse movements on the map - responsible for moving
* the cursor etc.
*
* @author Luke
*/
public class UserInputOnMapController extends KeyAdapter {
private static final String JFREERAILS_CLIENT_SOUNDS_BUILDTRACK_WAV = "/jfreerails/client/sounds/buildtrack.wav";
private static final Logger logger = Logger
.getLogger(UserInputOnMapController.class.getName());
private StationTypesPopup stationTypesPopup;
private BuildIndustryJPopupMenu buildIndustryJPopupMenu = new BuildIndustryJPopupMenu();
private MapViewJComponent mapView;
private TrackMoveProducer trackBuilder;
private DialogueBoxController dialogueBoxController;
private final ModelRoot modelRoot;
private final ActionRoot actionRoot;
private final MouseInputAdapter mouseInputAdapter = new CursorMouseAdapter();
/**
* Used to determine if mouse clicks are on trains.
*/
private TrainRenderer trainRenderer;
private BuildTrackController buildTrack;
private SoundManager soundManager = SoundManager.getSoundManager();
private boolean ignoreDragging = false;
public UserInputOnMapController(ModelRoot mr, ActionRoot ar) {
modelRoot = mr;
actionRoot = ar;
}
private class CursorMouseAdapter extends MouseInputAdapter {
private boolean pressedInside = false;
@Override
public void mouseClicked(MouseEvent evt) {
boolean isDoubleClick = evt.getClickCount() == 2;
ReadOnlyWorld w = modelRoot.getWorld();
FreerailsPrincipal principal = modelRoot.getPrincipal();
if (SwingUtilities.isLeftMouseButton(evt)) {
int x = evt.getX();
int y = evt.getY();
Double time = (Double) modelRoot.getProperty(Property.TIME);
int clickedTrain = -1;
//Iterate in reverse order since later trains are rendered over earlier ones.
for (int i = w.size(principal, KEY.TRAINS) -1; i >= 0 ; i--) {
TrainModel train = (TrainModel) w.get(principal, KEY.TRAINS, i);
TrainAccessor ta = new TrainAccessor(w, principal, i);
TrainPositionOnMap pos = ta.findPosition(time);
List<Map.Entry<Point, Step>> positions = trainRenderer.calcPositions(train, pos);
boolean hit = trainRenderer.isHit(evt.getPoint(), train, positions);
if(hit){
clickedTrain = i;
break;
}
}
if (clickedTrain != -1) {
modelRoot.setProperty(Property.SELECTED_TRAIN, clickedTrain);
if (isDoubleClick) {
dialogueBoxController.showTrainOrders(clickedTrain);
}
} else {
if (isDoubleClick) {
ImPoint cursorPosition = (ImPoint) modelRoot.getProperty(Property.CURSOR_POSITION);
dialogueBoxController.showStationOrTerrainInfo(cursorPosition.x,
cursorPosition.y);
}
}
}
}
@Override
public void mousePressed(MouseEvent evt
) {
if (SwingUtilities.isLeftMouseButton(evt)) {
ignoreDragging = false;
int x = evt.getX();
int y = evt.getY();
float scale = mapView.getScale();
Dimension tileSize = new Dimension((int) scale, (int) scale);
// only jump - no track building
moveCursorJump(new ImPoint(x / tileSize.width, y
/ tileSize.height));
mapView.requestFocus();
pressedInside = true;
/*
* Fix for bug [ 972866 ] Build track by dragging - only when
* build track selected
*/
boolean isBuildTrackModeSet = trackBuilder
.getTrackBuilderMode() == BUILD_TRACK;
if (isBuildTrackModeSet) {
buildTrack.show();
}
} else if (SwingUtilities.isRightMouseButton(evt)) {
// Cancel building track.
buildTrack.hide();
ignoreDragging = true;
setIgnoreKeyEvents(false);
}
}
@Override
public void mouseDragged(MouseEvent evt
) {
BuildMode trackBuilderMode = trackBuilder.getTrackBuilderMode();
/*
* Fix for bug [ 972866 ] Build track by dragging - only when build
* track selected
* Fix for bug [1537413 ] Exception when building station.
*/
boolean trackBuildingOn = (trackBuilderMode == BUILD_TRACK)
|| (trackBuilderMode == REMOVE_TRACK)
|| (trackBuilderMode == UPGRADE_TRACK);
trackBuildingOn = trackBuildingOn
&& (modelRoot.getProperty(ModelRoot.Property.CURSOR_MODE) == ModelRoot.Value.BUILD_TRACK_CURSOR_MODE);
if (SwingUtilities.isLeftMouseButton(evt) && pressedInside
&& trackBuildingOn && !ignoreDragging) {
setIgnoreKeyEvents(true);
int x = evt.getX();
int y = evt.getY();
float scale = mapView.getScale();
Dimension tileSize = new Dimension((int) scale, (int) scale);
int tileX = x / tileSize.width;
int tileY = y / tileSize.height;
/*
* See the javadoc for JComponent.setAutoscrolls(boolean
* autoscrolls)
*/
assert mapView.getAutoscrolls();
// Scroll view if necessary.
if (!mapView.getVisibleRect().contains(x, y)) {
/*
* Making the rectangle we scroll to 2 tiles wide and
* centered on x, y means that we scroll at least one tile.
* This stops painfully slow scrolling in full screen mode
* when the mouse cannot be dragged far from the viewport
* since it hits the screen edge.
*/
Rectangle r = new Rectangle(x - tileSize.width, y
- tileSize.height, 2 * tileSize.width,
2 * tileSize.height);
mapView.scrollRectToVisible(r);
}
ImPoint to = new ImPoint(
tileX, tileY);
buildTrack.setProposedTrack(to, trackBuilder);
mapView.requestFocus();
}
}
@Override
public void mouseReleased(MouseEvent evt
) {
if (SwingUtilities.isLeftMouseButton(evt)) {
ignoreDragging = false;
setIgnoreKeyEvents(false);
// build a railroad from x,y to current cursor position
if (pressedInside && buildTrack.isBuilding()
&& buildTrack.isBuildTrackSuccessful()) {
// Fix for bug [ 997088 ]
// Is current posisition different from original position?
int x = evt.getX();
int y = evt.getY();
float scale = mapView.getScale();
Dimension tileSize = new Dimension((int) scale, (int) scale);
int tileX = x / tileSize.width;
int tileY = y / tileSize.height;
if (getCursorPosition().x != tileX
|| getCursorPosition().y != tileY) {
// copy WorldDifferences from buildTrack to World
ImPoint newPosition = buildTrack
.updateWorld(trackBuilder);
setCursorPosition(newPosition);
}
}
pressedInside = false;
buildTrack.hide();
}
}
}
private void cursorOneTileMove(ImPoint oldPosition, Step vector) {
boolean b = (modelRoot.getProperty(ModelRoot.Property.CURSOR_MODE) == ModelRoot.Value.BUILD_TRACK_CURSOR_MODE);
if (null != trackBuilder && b) {
trackBuilder.setBuildTrackStrategy(getBts());
MoveStatus ms = trackBuilder.buildTrack(oldPosition, vector);
if (ms.ok) {
setCursorMessage("");
playAppropriateSound();
} else {
setCursorMessage(ms.message);
}
} else {
logger.warning("No track builder available!");
}
}
private void playAppropriateSound() {
switch (trackBuilder.getTrackBuilderMode()) {
case BUILD_TRACK:
case UPGRADE_TRACK:
soundManager.playSound(JFREERAILS_CLIENT_SOUNDS_BUILDTRACK_WAV, 0);
break;
case REMOVE_TRACK:
soundManager.playSound("/jfreerails/client/sounds/removetrack.wav",
0);
break;
default:
// do nothing
}
}
public void setup(MapViewJComponent mv, TrackMoveProducer trackBuilder,
StationTypesPopup stPopup, ModelRoot mr, DialogueBoxController dbc,
FreerailsCursor cursor, BuildTrackController buildTrack, TrainRenderer trainRenderer) {
this.dialogueBoxController = dbc;
this.mapView = mv;
this.stationTypesPopup = stPopup;
this.trackBuilder = trackBuilder;
this.buildTrack = buildTrack;
this.trainRenderer = trainRenderer;
buildIndustryJPopupMenu.setup(mr, null, null);
/*
* We attempt to remove listeners before adding them to prevent them
* being added several times.
*/
mapView.removeMouseListener(mouseInputAdapter);
mapView.addMouseListener(mouseInputAdapter);
mapView.removeMouseMotionListener(mouseInputAdapter);
mapView.addMouseMotionListener(mouseInputAdapter);
mapView.removeKeyListener(this);
mapView.addKeyListener(this);
}
private void cursorJumped(ImPoint to) {
// if (trackBuilder.getTrackBuilderMode() ==
// TrackMoveProducer.UPGRADE_TRACK) {
// MoveStatus ms = trackBuilder.upgradeTrack(to);
//
// if (ms.ok) {
// setCursorMessage("");
// playAppropriateSound();
// } else {
// setCursorMessage(ms.message);
// }
// }
}
private ImPoint getCursorPosition() {
ImPoint point = (ImPoint) modelRoot
.getProperty(ModelRoot.Property.CURSOR_POSITION);
// Check for null
point = null == point ? new ImPoint() : point;
return point;
}
private void setCursorPosition(ImPoint p) {
// Make a defensive copy.
ImPoint point = p;
modelRoot.setProperty(Property.CURSOR_POSITION, point);
}
private void setCursorMessage(String s) {
modelRoot.setProperty(Property.CURSOR_MESSAGE, s);
}
@Override
public void keyPressed(KeyEvent e) {
int keyCode = e.getKeyCode();
if (isIgnoreKeyEvents()) {
if (keyCode == KeyEvent.VK_ESCAPE) {
setIgnoreKeyEvents(false);
} else {
return;
}
}
ImPoint cursorPosition = getCursorPosition();
switch (keyCode) {
case KeyEvent.VK_NUMPAD1:
moveCursorOneTile(Step.SOUTH_WEST);
break;
case KeyEvent.VK_NUMPAD2:
moveCursorOneTile(Step.SOUTH);
break;
// @SonnyZ
case KeyEvent.VK_DOWN:
if (e.getModifiers() == 2) {
moveCursorOneTile(Step.SOUTH);
}
break;
// --
case KeyEvent.VK_NUMPAD3:
moveCursorOneTile(Step.SOUTH_EAST);
break;
case KeyEvent.VK_NUMPAD4:
moveCursorOneTile(Step.WEST);
break;
// @SonnyZ
case KeyEvent.VK_LEFT:
if (e.getModifiers() == 2) {
moveCursorOneTile(Step.WEST);
}
break;
// --
case KeyEvent.VK_NUMPAD6:
moveCursorOneTile(Step.EAST);
break;
// @SonnyZ
case KeyEvent.VK_RIGHT:
if (e.getModifiers() == 2) {
moveCursorOneTile(Step.EAST);
}
break;
// --
case KeyEvent.VK_NUMPAD7:
moveCursorOneTile(Step.NORTH_WEST);
break;
case KeyEvent.VK_NUMPAD8:
moveCursorOneTile(Step.NORTH);
break;
// @SonnyZ
case KeyEvent.VK_UP:
if (e.getModifiers() == 2) {
moveCursorOneTile(Step.NORTH);
}
break;
// --
case KeyEvent.VK_NUMPAD9:
moveCursorOneTile(Step.NORTH_EAST);
break;
case KeyEvent.VK_F8: {
// Check whether we can built a station here before proceeding.
if (stationTypesPopup.canBuiltStationHere(cursorPosition.toPoint())) {
float scale = mapView.getScale();
Dimension tileSize = new Dimension((int) scale, (int) scale);
int x = cursorPosition.x * tileSize.width;
int y = cursorPosition.y * tileSize.height;
stationTypesPopup.showMenu(mapView, x, y, cursorPosition
.toPoint());
} else {
modelRoot.setProperty(Property.QUICK_MESSAGE, "Can't"
+ " build station here!");
}
break;
}
case KeyEvent.VK_BACK_SPACE:
logger.info("Undo building track currently not implemented.");
//
// MoveStatus ms = trackBuilder.undoLastTrackMove();
//
// if (!ms.isOk()) {
// setCursorMessage(ms.message);
// }
break;
case KeyEvent.VK_I: {
dialogueBoxController.showStationOrTerrainInfo(cursorPosition.x,
cursorPosition.y);
break;
}
case KeyEvent.VK_C: {
mapView.centerOnTile(cursorPosition.toPoint());
break;
}
case KeyEvent.VK_B: {
float scale = mapView.getScale();
Dimension tileSize = new Dimension((int) scale, (int) scale);
int x = cursorPosition.x * tileSize.width;
int y = cursorPosition.y * tileSize.height;
buildIndustryJPopupMenu.setCursorLocation(cursorPosition.toPoint());
buildIndustryJPopupMenu.show(mapView, x, y);
break;
}
case KeyEvent.VK_ESCAPE: {
cancelProposedBuild();
break;
}
// @author SonnyZ
case KeyEvent.VK_X: {
// modelRoot.setProperty(Property.QUICK_MESSAGE, keyCode + " was
// pressed!");
dialogueBoxController.showExitDialog();
break;
}
// @SonnyZ
case KeyEvent.VK_S: {
if (e.getModifiers() == 2) {
ServerControlModel cont = actionRoot.getServerControls();
// String name = JOptionPane.showInputDialog(null, "Saved Game
// Name:","Save
// Game",JOptionPane.QUESTION_MESSAGE,null,null,modelRoot.getPrincipal().getName()).toString();
// modelRoot.setProperty(Property.QUICK_MESSAGE, name);
cont.getSaveGameAction().actionPerformed(null);
}
break;
}
// @SonnyZ
case KeyEvent.VK_L: {
if (e.getModifiers() == 2) {
ServerControlModel cont = actionRoot.getServerControls();
cont.getLoadGameAction().actionPerformed(null);
}
break;
}
// @SonnyZ
case KeyEvent.VK_M: {
// if the screen is not clicked after the broker screen is closed
// and 'M' is pressed
// again, the broker screen will never show up again.
dialogueBoxController.showBrokerScreen();
break;
}
case KeyEvent.VK_F12: {
System.out.println("Disable keyboard input!");
setIgnoreKeyEvents(true);
break;
}
}
}
private void cancelProposedBuild() {
ignoreDragging = true;
buildTrack.hide();
StationBuildModel sbm = actionRoot.getStationBuildModel();
sbm.getStationCancelAction().actionPerformed(
new ActionEvent(this, ActionEvent.ACTION_PERFORMED, ""));
setIgnoreKeyEvents(false);
}
private void moveCursorJump(ImPoint tryThisPoint) {
setCursorMessage("");
if (legalRectangleContains(tryThisPoint)) {
setCursorPosition(tryThisPoint);
cursorJumped(tryThisPoint);
} else {
this.setCursorMessage("Illegal cursor position!");
}
}
/**
* Checks whether specified point is in legal rectangle.
*
* @param tryThisPoint ImPoint
* @return boolean
*/
private boolean legalRectangleContains(ImPoint tryThisPoint) {
ReadOnlyWorld world = modelRoot.getWorld();
int width = world.getMapWidth();
int height = world.getMapHeight();
Rectangle legalRectangle = new Rectangle(0, 0, width, height);
return legalRectangle.contains(tryThisPoint.toPoint());
}
private void moveCursorOneTile(Step v) {
setCursorMessage(null);
ImPoint cursorMapPosition = this.getCursorPosition();
ImPoint tryThisPoint = new ImPoint(cursorMapPosition.x + v.getDx(),
cursorMapPosition.y + v.getDy());
/* Move the cursor. */
if (legalRectangleContains(tryThisPoint)) {
setCursorPosition(tryThisPoint);
cursorOneTileMove(cursorMapPosition, v);
} else {
this.setCursorMessage("Illegal cursor position!");
}
}
private BuildTrackStrategy getBts() {
BuildTrackStrategy bts = (BuildTrackStrategy) modelRoot
.getProperty(ModelRoot.Property.BUILD_TRACK_STRATEGY);
if (null == bts) {
throw new NullPointerException();
}
return bts;
}
private void setIgnoreKeyEvents(boolean ignoreKeyEvents) {
modelRoot.setProperty(Property.IGNORE_KEY_EVENTS, Boolean
.valueOf(ignoreKeyEvents));
}
private boolean isIgnoreKeyEvents() {
Boolean b = (Boolean) modelRoot.getProperty(Property.IGNORE_KEY_EVENTS);
return b.booleanValue();
}
}

/**
* This class inspects incoming moves and generates a user message if
* appropriate. It is also used to trigger sounds.
*
* @author Luke
*
*/
public class UserMessageGenerator implements MoveReceiver {
private ModelRoot modelRoot;
private ActionRoot actionRoot;
private final DecimalFormat formatter = new DecimalFormat("#,###,###");
private SoundManager soundManager = SoundManager.getSoundManager();
public UserMessageGenerator(ModelRoot mr, ActionRoot actionRoot) {
if (null == mr || null == actionRoot) {
throw new NullPointerException();
}
this.actionRoot = actionRoot;
this.modelRoot = mr;
}
public void processMove(Move move) {
if (move instanceof CompositeMove) {
ImList<Move> moves = ((CompositeMove) move).getMoves();
for (int i = 0; i < moves.size(); i++) {
processMove(moves.get(i));
}
}
if (move instanceof WorldDiffMove) {
WorldDiffMove wdm = (WorldDiffMove) move;
if (wdm.getCause().equals(WorldDiffMove.Cause.TrainArrives)) {
trainArrives(wdm);
}
} else if (move instanceof ChangeGameSpeedMove) {
logSpeed();
}
}
/** Generates a message giving details of any cargo delivered and plays
* a cash register sound to indicate that revenue is coming in.
*/
private void trainArrives(WorldDiffMove wdm) {
ArrayList<DeliverCargoReceipt> cargoDelivered = new ArrayList<DeliverCargoReceipt>();
CompositeMove listChanges = wdm.getListChanges();
for (int i = 0; i < listChanges.size(); i++) {
Move m = listChanges.getMoves().get(i);
if (m instanceof AddTransactionMove) {
AddTransactionMove atm = (AddTransactionMove) m;
if(!atm.getPrincipal().equals(modelRoot.getPrincipal())){
//We don't want to know about other players' income!
return;
}
Transaction t = atm.getTransaction();
if (t instanceof DeliverCargoReceipt) {
DeliverCargoReceipt receipt = (DeliverCargoReceipt) t;
cargoDelivered.add(receipt);
}
}
}
if (cargoDelivered.size() > 0) {
ReadOnlyWorld world = modelRoot.getWorld();
StringBuffer message = new StringBuffer();
DeliverCargoReceipt first = cargoDelivered.get(0);
int stationId = first.getStationId();
int trainId = first.getTrainId();
message.append("Train #");
message.append(trainId + 1); // So that the first train
// is #1, not #0.
message.append(" arrives at ");
StationModel station = (StationModel) world.get(modelRoot
.getPrincipal(), KEY.STATIONS, stationId);
message.append(station.getStationName());
message.append("\n");
long revenue = 0;
int[] cargoQuantities = new int[modelRoot.getWorld().size(
SKEY.CARGO_TYPES)];
for (DeliverCargoReceipt receipt : cargoDelivered) {
CargoBatch batch = receipt.getCb();
revenue += receipt.deltaCash().getAmount();
cargoQuantities[batch.getCargoType()] = receipt
.getQuantity();
}
for (int i = 0; i < cargoQuantities.length; i++) {
int j = cargoQuantities[i];
if (j > 0) {
CargoType cargoType = (CargoType) world.get(
SKEY.CARGO_TYPES, i);
message.append(j);
message.append(" ");
message.append(cargoType.getDisplayName());
message.append("\n");
}
}
message.append("Revenue $");
message.append(formatter.format(revenue));
modelRoot.setProperty(Property.QUICK_MESSAGE, message
.toString());
// Play the sound of cash coming in. The greater the
// revenue,
// the more loops of the sample we play.
int loops = (int) revenue / 4000;
try {
soundManager.playSound(
"/jfreerails/client/sounds/cash.wav", loops);
} catch (Exception e) {
e.printStackTrace();
}
}
}
public void logSpeed() {
ReadOnlyWorld world = modelRoot.getWorld();
GameSpeed speed = ((GameSpeed) world.get(ITEM.GAME_SPEED));
int gameSpeed = speed.getSpeed();
if (gameSpeed <= 0) {
modelRoot
.setProperty(Property.PERMANENT_MESSAGE, "Game is paused.");
/*
* Also hide any other message. It looks silly if it says "Game is
* paused." and "Game speed: fast" on screen at the same time!
*/
modelRoot.setProperty(Property.QUICK_MESSAGE, "");
} else {
modelRoot.setProperty(Property.PERMANENT_MESSAGE, null);
String gameSpeedDesc = actionRoot.getServerControls()
.getGameSpeedDesc(gameSpeed);
modelRoot.setProperty(Property.QUICK_MESSAGE, "Game speed: "
+ gameSpeedDesc);
}
}
}

/**
* Provides access to Actions change the game state and the GUI.
*
* @author Luke
*
*/
public class ActionRoot {
private class BuildTrainDialogAction extends AbstractAction {
private static final long serialVersionUID = 3257853173002416948L;
public BuildTrainDialogAction() {
super("Build Train");
putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_F7, 0));
putValue(SHORT_DESCRIPTION, "Build a new train");
}
public void actionPerformed(ActionEvent e) {
if (dialogueBoxController != null) {
dialogueBoxController.showSelectEngine();
}
}
}
private final BuildTrainDialogAction buildTrainDialogAction = new BuildTrainDialogAction();
private DialogueBoxController dialogueBoxController = null;
private final ServerControlModel serverControls;
private StationBuildModel stationBuildModel;
private TrackMoveProducer trackMoveProducer;
public ActionRoot(ModelRootImpl mr) {
this.serverControls = new ServerControlModel(mr);
}
public Action getBuildTrainDialogAction() {
return buildTrainDialogAction;
}
public DialogueBoxController getDialogueBoxController() {
return dialogueBoxController;
}
public ServerControlModel getServerControls() {
return serverControls;
}
public StationBuildModel getStationBuildModel() {
return stationBuildModel;
}
public TrackMoveProducer getTrackMoveProducer() {
return trackMoveProducer;
}
public void setDialogueBoxController(
DialogueBoxController dialogueBoxController) {
this.dialogueBoxController = dialogueBoxController;
}
/**
* Call this method when a new game is started or a game is loaded.
*/
public void setup(ModelRootImpl modelRoot, RenderersRoot vl) {
serverControls.setup(modelRoot, dialogueBoxController);
if (!modelRoot.hasBeenSetup)
throw new IllegalStateException();
ReadOnlyWorld world = modelRoot.getWorld();
if (world.size(SKEY.TRACK_RULES) > 0) {
trackMoveProducer = new TrackMoveProducer(modelRoot);
stationBuildModel = new StationBuildModel(new StationBuilder(
modelRoot), vl, modelRoot);
}
}
}

/**
* Defines a standard method to initiate GUI components that need access to the
* ModelRoot <b> and </b> the ActionRoot.
*
* @author Luke
*
*/
public interface ActiveView {
void setup(ModelRoot modelRoot, ActionRoot ar, RenderersRoot vl,
ActionListener submitButtonCallBack);
}

/**
* A HtmlJPanel that displays the balance sheet.
*
* @author Luke
*
*/
public class BalanceSheetHtmlJPanel extends HtmlJPanel implements View {
private static final long serialVersionUID = 3257009873370886964L;
private String template;
private int lastNumTransactions = 0;
private ModelRoot modelRoot;
public BalanceSheetHtmlJPanel() {
super();
URL url = BalanceSheetHtmlJPanel.class
.getResource("/jfreerails/client/view/balance_sheet.htm");
template = loadText(url);
}
@Override
public void setup(ModelRoot modelRoot, RenderersRoot vl, Action closeAction) {
super.setup(modelRoot, vl, closeAction);
this.modelRoot = modelRoot;
updateHtml();
}
private void updateHtml() {
ReadOnlyWorld world = modelRoot.getWorld();
FreerailsPrincipal playerPrincipal = modelRoot.getPrincipal();
BalanceSheetGenerator balanceSheetGenerator = new BalanceSheetGenerator(
world, playerPrincipal);
String populatedTemplate = populateTokens(template,
balanceSheetGenerator);
setHtml(populatedTemplate);
}
@Override
protected void paintComponent(Graphics g) {
/* Check to see if the text needs updating before painting. */
ReadOnlyWorld world = modelRoot.getWorld();
FreerailsPrincipal playerPrincipal = modelRoot.getPrincipal();
int currentNumberOfTransactions = world
.getNumberOfTransactions(playerPrincipal);
if (currentNumberOfTransactions != lastNumTransactions) {
updateHtml();
}
super.paintComponent(g);
}
}

/**
* @author smackay
* @author Luke
*/
public class BrokerJFrame extends javax.swing.JInternalFrame {
private static final long serialVersionUID = 4121409622587815475L;
private static final Logger logger = Logger.getLogger(BrokerJFrame.class
.getName());
/** Creates new form BrokerJFrame */
BrokerJFrame() {
initComponents();
}
public BrokerJFrame(URL url) {
initComponents();
setHtml(loadText(url));
}
public BrokerJFrame(URL url, HashMap context) {
initComponents();
String template = loadText(url);
String populatedTemplate = populateTokens(template, context);
setHtml(populatedTemplate);
}
public BrokerJFrame(String html) {
initComponents();
setHtml(html);
}
public void setup(ModelRoot m, RenderersRoot vl,
Action closeAction) {
this.done.setAction(closeAction);
}
/** Load the help text from file. */
String loadText(final URL htmlUrl) {
try {
InputStream in = htmlUrl.openStream();
BufferedReader br = new BufferedReader(new InputStreamReader(
new DataInputStream(in)));
String line;
String text = "";
while ((line = br.readLine()) != null) {
text = text + line;
}
return text;
} catch (Exception e) {
e.printStackTrace();
logger.warning(htmlUrl.toString());
return "Couldn't read: " + htmlUrl;
}
}
void setHtml(String s) {
htmlJLabel.setText(s);
}
public String populateTokens(String template, Object context) {
StringTokenizer tokenizer = new StringTokenizer(template, "$");
String output = "";
while (tokenizer.hasMoreTokens()) {
output += tokenizer.nextToken();
if (tokenizer.hasMoreTokens()) {
String token = tokenizer.nextToken();
String value;
if (context instanceof HashMap) {
value = (String) ((HashMap) context).get(token);
} else {
try {
Field field = context.getClass().getField(token);
value = field.get(context).toString();
} catch (Exception e) {
e.printStackTrace();
throw new NoSuchElementException(token);
}
}
output += value;
}
}
return output;
}
/** This method is called from within the constructor to
* initialize the form.
* WARNING: Do NOT modify this code. The content of this method is
* always regenerated by the Form Editor.
*/
// <editor-fold defaultstate="collapsed" desc=" Generated Code ">//GEN-BEGIN:initComponents
private void initComponents() {
java.awt.GridBagConstraints gridBagConstraints;
jScrollPane1 = new javax.swing.JScrollPane();
jPanel1 = new javax.swing.JPanel();
htmlJLabel = new javax.swing.JLabel();
done = new javax.swing.JButton();
brokerMenu = new javax.swing.JMenuBar();
bonds = new javax.swing.JMenu();
issueBond = new javax.swing.JMenuItem();
repayBond = new javax.swing.JMenuItem();
stocks = new javax.swing.JMenu();
getContentPane().setLayout(new java.awt.GridBagLayout());
jScrollPane1.setVerticalScrollBarPolicy(javax.swing.ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
jPanel1.setLayout(new java.awt.BorderLayout());
htmlJLabel.setFont(new java.awt.Font("Dialog", 0, 12));
htmlJLabel.setText("sdfa");
htmlJLabel.setVerticalAlignment(javax.swing.SwingConstants.TOP);
htmlJLabel.setVerticalTextPosition(javax.swing.SwingConstants.TOP);
jPanel1.add(htmlJLabel, java.awt.BorderLayout.CENTER);
jScrollPane1.setViewportView(jPanel1);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
getContentPane().add(jScrollPane1, gridBagConstraints);
done.setText("Close");
done.setVerifyInputWhenFocusTarget(false);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.insets = new java.awt.Insets(7, 7, 7, 7);
getContentPane().add(done, gridBagConstraints);
bonds.setText("Bonds");
issueBond.setText("Issue Bond");
bonds.add(issueBond);
repayBond.setText("Repay Bond");
bonds.add(repayBond);
brokerMenu.add(bonds);
stocks.setText("Stocks");
brokerMenu.add(stocks);
setJMenuBar(brokerMenu);
pack();
}
// </editor-fold>//GEN-END:initComponents
// Variables declaration - do not modify//GEN-BEGIN:variables
javax.swing.JMenu bonds;
javax.swing.JMenuBar brokerMenu;
javax.swing.JButton done;
javax.swing.JLabel htmlJLabel;
javax.swing.JMenuItem issueBond;
javax.swing.JPanel jPanel1;
javax.swing.JScrollPane jScrollPane1;
javax.swing.JMenuItem repayBond;
javax.swing.JMenu stocks;
// End of variables declaration//GEN-END:variables
}

/**
*
* @author smackay
* @author Luke
*/
public class BrokerScreenGenerator {
private static final DecimalFormat DC = new DecimalFormat("#,###");
private FinancialDataGatherer dataGatherer;
private GameCalendar cal;
public String playername;
public String year;
public Money cash;
public Money loansTotal;
public Money netWorth;
public Money pricePerShare;
public String publicShares;
public String treasuryStock;
public String othersRRsStockRows;
/** Creates a new instance of BrokerScreenGenerator */
public BrokerScreenGenerator(ReadOnlyWorld w, FreerailsPrincipal principal) {
dataGatherer = new FinancialDataGatherer(w, principal);
int playerId = w.getID(principal);
this.playername = w.getPlayer(playerId).getName();
this.cal = (GameCalendar) w.get(ITEM.CALENDAR);
GameTime time = w.currentTime();
final int startyear = cal.getYear(time.getTicks());
this.year = String.valueOf(startyear);
this.cash = w.getCurrentBalance(principal);
ItemsTransactionAggregator aggregator = new ItemsTransactionAggregator(
w, principal);
aggregator.setCategory(BOND);
this.loansTotal = aggregator.calculateValue();
this.publicShares = DC.format(dataGatherer.sharesHeldByPublic());
this.netWorth = dataGatherer.netWorth();
StockPrice[] stockPrices = (new StockPriceCalculator(w)).calculate();
this.pricePerShare = stockPrices[playerId].currentPrice;
this.treasuryStock = DC.format(dataGatherer.treasuryStock());
StringBuffer otherRRsStakes = new StringBuffer();
int[] stockInThisRRs = dataGatherer.getStockInThisRRs();
for (int i = 0; i < stockInThisRRs.length; i++) {
if (i != playerId && stockInThisRRs[i] > 0) {
String otherRRName = w.getPlayer(i).getName();
String otherRRStake = DC.format(stockInThisRRs[i]);
otherRRsStakes.append("<tr> ");
otherRRsStakes.append("<td> </td>");
otherRRsStakes.append("<td> </td>");
otherRRsStakes.append("<td>" + otherRRName + "</td>");
otherRRsStakes.append("<td>" + otherRRStake + "</td>");
otherRRsStakes.append("</tr>");
}
}
othersRRsStockRows = otherRRsStakes.toString();
}
}

/**
*
* @author smackay
* @author Luke
*/
public class BrokerScreenHtmlJFrame extends BrokerJFrame implements View {
private static final long serialVersionUID = 3257003246252800050L;
private String template;
private int lastNumTransactions = 0;
private ModelRoot modelRoot;
public static BrokerScreenGenerator brokerScreenGenerator;
private FinancialDataGatherer financialDataGatherer;
private Action[] buyStock, sellStock;
/** Creates a new instance of BrokerScreenHtmlJPanel */
public BrokerScreenHtmlJFrame() {
super();
URL url = BrokerScreenHtmlJFrame.class
.getResource("/jfreerails/client/view/Broker_Screen.html");
template = loadText(url);
this.setSize(550, 300);
}
private final Action issueBondAction = new AbstractAction("Issue bond") {
private static final long serialVersionUID = 1L;
public void actionPerformed(ActionEvent arg0) {
if (financialDataGatherer.canIssueBond()) {
Move bondTransaction = new AddTransactionMove(modelRoot
.getPrincipal(),
BondTransaction.issueBond(financialDataGatherer
.nextBondInterestRate()));
modelRoot.doMove(bondTransaction);
}
}
};
private final Action repayBondAction = new AbstractAction("Repay bond") {
private static final long serialVersionUID = 1L;
public void actionPerformed(ActionEvent arg0) {
Move bondTransaction = new AddTransactionMove(modelRoot
.getPrincipal(), BondTransaction.repayBond(5));
modelRoot.doMove(bondTransaction);
}
};
@Override
public void setup(final ModelRoot modelRoot, RenderersRoot vl,
Action closeAction) {
super.setup(modelRoot, vl, closeAction);
financialDataGatherer = new FinancialDataGatherer(modelRoot.getWorld(),
modelRoot.getPrincipal());
this.modelRoot = modelRoot;
setupStockMenu();
updateHtml();
// Sets up the BrokerScreen and Adds ActionListeners to the Menu
issueBond.setAction(issueBondAction);
repayBond.setAction(repayBondAction);
}
private void setupStockMenu(){
stocks.removeAll();
ReadOnlyWorld world = modelRoot.getWorld();
int thisPlayerId = world.getID(modelRoot.getPrincipal());
int numberOfPlayers = world.getNumberOfPlayers();
buyStock = new Action[numberOfPlayers];
sellStock = new Action[numberOfPlayers];
for(int playerId = 0 ; playerId < numberOfPlayers; playerId++){
final boolean isThisPlayer = playerId == thisPlayerId;
final int otherPlayerId = playerId;
Player otherPlayer = world.getPlayer(playerId);
String playerLabel = isThisPlayer ? "Treasury stock" : otherPlayer.getName();
String buyLabel = "Buy 10,000 shares of " + playerLabel;
String sellLabel = "Sell 10,000 shares of " + playerLabel;
buyStock[playerId] = new AbstractAction(buyLabel) {
private static final long serialVersionUID = 1L;
public void actionPerformed(ActionEvent arg0) {
StockPrice stockPrice = new StockPriceCalculator(modelRoot.getWorld()).calculate()[otherPlayerId];
Money sharePrice = isThisPlayer ? stockPrice.treasuryBuyPrice : stockPrice.buyPrice;
StockTransaction t = StockTransaction
.buyOrSellStock(otherPlayerId, StockTransaction.STOCK_BUNDLE_SIZE, sharePrice);
Move move = new AddTransactionMove(modelRoot.getPrincipal(), t);
modelRoot.doMove(move);
updateHtml();
}
};
sellStock[playerId] = new AbstractAction(sellLabel) {
private static final long serialVersionUID = 1L;
public void actionPerformed(ActionEvent arg0) {
StockPrice stockPrice = new StockPriceCalculator(modelRoot.getWorld()).calculate()[otherPlayerId];
Money sharePrice = isThisPlayer ? stockPrice.treasurySellPrice : stockPrice.sellPrice;
StockTransaction t = StockTransaction
.buyOrSellStock(otherPlayerId, -StockTransaction.STOCK_BUNDLE_SIZE, sharePrice);
Move move = new AddTransactionMove(modelRoot.getPrincipal(), t);
modelRoot.doMove(move);
updateHtml();
}
};
stocks.add(buyStock[playerId]);
stocks.add(sellStock[playerId]);
}
enableAndDisableActions();
}
private void enableAndDisableActions(){
ReadOnlyWorld world = modelRoot.getWorld();
FreerailsPrincipal p = modelRoot.getPrincipal();
FinancialDataGatherer thisDataGatherer = new FinancialDataGatherer(
world, p);
StockPrice[] stockPrices = new StockPriceCalculator(world).calculate();
long highestAffordablePrice = world.getCurrentBalance(p).getAmount() / StockTransaction.STOCK_BUNDLE_SIZE;
//Enable and disable stock actions.
for(int playerId = 0; playerId < world.getNumberOfPlayers(); playerId++){
Player temp = modelRoot.getWorld().getPlayer(playerId);
FreerailsPrincipal otherPrincipal = temp.getPrincipal();
FinancialDataGatherer otherDataGatherer = new FinancialDataGatherer(world, otherPrincipal);
//If this RR has stock in other RR, then enable sell stock
boolean hasStockInRR = thisDataGatherer.getStockInRRs()[playerId] > 0;
sellStock[playerId].setEnabled(hasStockInRR);
//If the public own some stock, then enable buy stock.
boolean isStockAvailable = otherDataGatherer.sharesHeldByPublic() > 0;
buyStock[playerId].setEnabled(isStockAvailable);
//Don't let player buy 100% of treasury stock.
if(otherPrincipal.equals(p)){
int treasuryStock = otherDataGatherer.treasuryStock();
int totalStock = otherDataGatherer.totalShares();
if(StockTransaction.STOCK_BUNDLE_SIZE + treasuryStock >= totalStock){
buyStock[playerId].setEnabled(false);
}
}
//Don't let the player buy stock if they cannot afford it.
if(stockPrices[playerId].currentPrice.getAmount() > highestAffordablePrice){
buyStock[playerId].setEnabled(false);
}
}
//Enable and disable bond actions.
int outstandingBonds = thisDataGatherer.getBonds();
repayBondAction.setEnabled(outstandingBonds > 0);
issueBondAction.setEnabled(outstandingBonds < 4);
}
private void updateHtml() {
ReadOnlyWorld world = modelRoot.getWorld();
FreerailsPrincipal p = modelRoot.getPrincipal();
brokerScreenGenerator = new BrokerScreenGenerator(world, p);
// this is where the Menu get Enable and Disable by if you own any stock
// or if the TotalShares are 0
StringBuffer populatedTemplate = new StringBuffer();
populatedTemplate.append("<html>");
populatedTemplate
.append(populateTokens(template, brokerScreenGenerator));
for (int i = 0; i < world.getNumberOfPlayers(); i++) {
if (!(world.getPlayer(i).getPrincipal().equals(p))) {
BrokerScreenGenerator temp = new BrokerScreenGenerator(world,
world.getPlayer(i).getPrincipal());
populatedTemplate.append(populateTokens(template, temp));
}
}
populatedTemplate.append("</html>");
String html = populatedTemplate.toString();
setHtml(html);
enableAndDisableActions();
}
@Override
protected void paintComponent(Graphics g) {
/* Check to see if the text needs updating before painting. */
ReadOnlyWorld world = modelRoot.getWorld();
FreerailsPrincipal playerPrincipal = modelRoot.getPrincipal();
int currentNumberOfTransactions = world
.getNumberOfTransactions(playerPrincipal);
if (currentNumberOfTransactions != lastNumTransactions) {
updateHtml();
}
super.paintComponent(g);
}
}

/**
* A JPanel that presents toggle buttons that let the player select the build
* mode (build track, upgrade track, build station, bulldoze, and info mode) and
* select the track/bridge/station type to use.
*
* @author Luke
*/
public class BuildTrackJPanel extends javax.swing.JPanel implements ActiveView {
private static final long serialVersionUID = 3618701915647850036L;
private final ImageManager imageManager = new ImageManagerImpl(
"/jfreerails/client/graphics/");
private HashMap<TrackRule.TrackCategories, Integer> selectionSet;
private ModelRoot modelRoot;
private TrackMoveProducer trackMoveProducer;
private StationBuildModel stationBuildModel;
/** Creates new form BuildTrackJPanel */
public BuildTrackJPanel() {
initComponents();
}
public void setup(ModelRoot mr, ActionRoot ar, RenderersRoot vl,
ActionListener al) {
modelRoot = mr;
stationBuildModel = ar.getStationBuildModel();
trackMoveProducer = ar.getTrackMoveProducer();
if (null == trackMoveProducer)
throw new NullPointerException();
selectionSet = new HashMap<TrackRule.TrackCategories, Integer>();
trackButtonGroup = new javax.swing.ButtonGroup();
bridgeButtonGroup = new javax.swing.ButtonGroup();
stationButtonGroup = new javax.swing.ButtonGroup();
tunnelButtonGroup = new javax.swing.ButtonGroup();
// Remove any existing buttons.
bridgesJPanel.removeAll();
stationsJPanel.removeAll();
trackJPanel.removeAll();
tunnelsJPanel.removeAll();
// Add the new set of buttons.
ReadOnlyWorld world = mr.getWorld();
for (int i = 0; i < world.size(SKEY.TRACK_RULES); i++) {
JToggleButton toggleButton = new JToggleButton();
final Integer ruleID = new Integer(i);
TrackRule rule = (TrackRule) world.get(SKEY.TRACK_RULES, i);
TrackRule.TrackCategories category = rule.getCategory();
Money price = null;
switch (category) {
case track:
trackButtonGroup.add(toggleButton);
toggleButton.setIcon(getIcon(rule.getTypeName()));
toggleButton
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(
java.awt.event.ActionEvent evt) {
selectionSet
.put(TrackRule.TrackCategories.track,
ruleID);
setBuildTrackStrategy();
}
});
price = rule.getPrice();
trackJPanel.add(toggleButton);
break;
case bridge:
bridgeButtonGroup.add(toggleButton);
toggleButton.setIcon(getIcon(rule.getTypeName()));
toggleButton
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(
java.awt.event.ActionEvent evt) {
selectionSet.put(
TrackRule.TrackCategories.bridge,
ruleID);
setBuildTrackStrategy();
}
});
bridgesJPanel.add(toggleButton);
price = rule.getFixedCost();
break;
case tunnel:
tunnelButtonGroup.add(toggleButton);
toggleButton.setIcon(getIcon(rule.getTypeName()));
toggleButton
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(
java.awt.event.ActionEvent evt) {
selectionSet.put(
TrackRule.TrackCategories.tunnel,
ruleID);
setBuildTrackStrategy();
}
});
price = rule.getPrice();
tunnelsJPanel.add(toggleButton);
break;
case station:
stationButtonGroup.add(toggleButton);
toggleButton.setAction(stationBuildModel
.getStationChooseAction(ruleID));
toggleButton.setIcon(getIcon(rule.getTypeName()));
toggleButton
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(
java.awt.event.ActionEvent evt) {
selectionSet.put(
TrackRule.TrackCategories.station,
ruleID);
}
});
stationsJPanel.add(toggleButton);
price = rule.getFixedCost();
break;
}
toggleButton.setPreferredSize(new java.awt.Dimension(36, 36));
String tooltip = Utils.capitalizeEveryWord(rule.getTypeName())
+ " $" + price.toString();
toggleButton.setToolTipText(tooltip);
if (!selectionSet.containsKey(category)) {
selectionSet.put(category, new Integer(i));
toggleButton.setSelected(true);
}
}
addNoTunnelsButton();
addNoBridgesButton();
// Default to add track.
addTrackActionPerformed(null);
buildModeButtonGroup.setSelected(addTrack.getModel(), true);
setBuildTrackStrategy();
// Make the buttons non-focusable
setFocusableFalse(bridgeButtonGroup);
setFocusableFalse(trackButtonGroup);
setFocusableFalse(tunnelButtonGroup);
setFocusableFalse(stationButtonGroup);
setFocusableFalse(buildModeButtonGroup);
// Add button click
// buildTrackJPanel.addKeyListener(new KeyListener(){
// public void keyPressed(KeyEvent e){
// System.out.println(e.getKeyCode());
// viewMode.doClick();
// }
// public void keyReleased(KeyEvent e){
//
// }
// public void keyTyped(KeyEvent e){
//
// }
// });
}
/** Calls setFocusable(false) for each button in the button group. */
private void setFocusableFalse(ButtonGroup bg) {
for (Enumeration<AbstractButton> buttons = bg.getElements(); buttons
.hasMoreElements();) {
buttons.nextElement().setFocusable(false);
}
}
private void addNoTunnelsButton() {
JToggleButton toggleButton = new JToggleButton();
tunnelButtonGroup.add(toggleButton);
toggleButton.setIcon(getIcon("no_tunnels"));
toggleButton.setPreferredSize(new java.awt.Dimension(36, 36));
toggleButton.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
selectionSet.put(TrackRule.TrackCategories.tunnel, null);
setBuildTrackStrategy();
}
});
toggleButton.setToolTipText("Don't build tunnels");
tunnelsJPanel.add(toggleButton);
}
private void addNoBridgesButton() {
JToggleButton toggleButton = new JToggleButton();
bridgeButtonGroup.add(toggleButton);
toggleButton.setIcon(getIcon("no_bridges"));
toggleButton.setPreferredSize(new java.awt.Dimension(36, 36));
toggleButton.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
selectionSet.put(TrackRule.TrackCategories.bridge, null);
setBuildTrackStrategy();
}
});
toggleButton.setToolTipText("Don't build bridges");
bridgesJPanel.add(toggleButton);
}
private ImageIcon getIcon(String typeName) {
try {
String relativeFileName = "icons" + File.separator + typeName
+ ".png";
relativeFileName = relativeFileName.replace(' ', '_');
Image im = imageManager.getImage(relativeFileName);
return new ImageIcon(im);
} catch (IOException e) {
e.printStackTrace();
throw new IllegalStateException(e);
}
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
private void initComponents() {// GEN-BEGIN:initComponents
java.awt.GridBagConstraints gridBagConstraints;
buildModeButtonGroup = new javax.swing.ButtonGroup();
trackButtonGroup = new javax.swing.ButtonGroup();
bridgeButtonGroup = new javax.swing.ButtonGroup();
stationButtonGroup = new javax.swing.ButtonGroup();
tunnelButtonGroup = new javax.swing.ButtonGroup();
buildModeJPanel = new javax.swing.JPanel();
addTrack = new javax.swing.JToggleButton();
upgradeTrack = new javax.swing.JToggleButton();
addStation = new javax.swing.JToggleButton();
bulldoze = new javax.swing.JToggleButton();
viewMode = new javax.swing.JToggleButton();
trackJPanel = new javax.swing.JPanel();
viewMode1 = new javax.swing.JToggleButton();
bridgesJPanel = new javax.swing.JPanel();
viewMode2 = new javax.swing.JToggleButton();
tunnelsJPanel = new javax.swing.JPanel();
viewMode3 = new javax.swing.JToggleButton();
stationsJPanel = new javax.swing.JPanel();
viewMode4 = new javax.swing.JToggleButton();
spacer = new javax.swing.JPanel();
setLayout(new java.awt.GridBagLayout());
setFocusable(false);
addKeyListener(new java.awt.event.KeyAdapter() {
@Override
public void keyPressed(java.awt.event.KeyEvent evt) {
formKeyPressed(evt);
}
@Override
public void keyTyped(java.awt.event.KeyEvent evt) {
formKeyTyped(evt);
}
});
buildModeJPanel.setLayout(new java.awt.FlowLayout(
java.awt.FlowLayout.LEFT, 4, 2));
buildModeButtonGroup.add(addTrack);
addTrack.setIcon(getIcon("build track"));
addTrack.setSelected(true);
addTrack.setToolTipText("Build Track");
addTrack.setFocusable(false);
addTrack.setPreferredSize(new java.awt.Dimension(36, 36));
addTrack.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
addTrackActionPerformed(evt);
}
});
buildModeJPanel.add(addTrack);
buildModeButtonGroup.add(upgradeTrack);
upgradeTrack.setIcon(getIcon("upgrade track"));
upgradeTrack.setToolTipText("Upgrade Track");
upgradeTrack.setFocusable(false);
upgradeTrack.setPreferredSize(new java.awt.Dimension(36, 36));
upgradeTrack.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
upgradeTrackActionPerformed(evt);
}
});
buildModeJPanel.add(upgradeTrack);
buildModeButtonGroup.add(addStation);
addStation.setIcon(getIcon("build stations"));
addStation.setToolTipText("Build Station");
addStation.setFocusable(false);
addStation.setPreferredSize(new java.awt.Dimension(36, 36));
addStation.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
addStationActionPerformed(evt);
}
});
buildModeJPanel.add(addStation);
buildModeButtonGroup.add(bulldoze);
bulldoze.setIcon(getIcon("bulldozer"));
bulldoze.setToolTipText("Remove Track");
bulldoze.setFocusable(false);
bulldoze.setPreferredSize(new java.awt.Dimension(36, 36));
bulldoze.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
bulldozeActionPerformed(evt);
}
});
buildModeJPanel.add(bulldoze);
buildModeButtonGroup.add(viewMode);
viewMode.setIcon(getIcon("eye"));
viewMode.setToolTipText("Don't build anything");
viewMode.setFocusable(false);
viewMode.setPreferredSize(new java.awt.Dimension(36, 36));
viewMode.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
viewModeActionPerformed(evt);
}
});
buildModeJPanel.add(viewMode);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 0;
gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
add(buildModeJPanel, gridBagConstraints);
trackJPanel.setLayout(new java.awt.FlowLayout(java.awt.FlowLayout.LEFT,
4, 2));
buildModeButtonGroup.add(viewMode1);
viewMode1.setIcon(getIcon("turn_off"));
viewMode1.setPreferredSize(new java.awt.Dimension(36, 36));
trackJPanel.add(viewMode1);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
add(trackJPanel, gridBagConstraints);
bridgesJPanel.setLayout(new java.awt.FlowLayout(
java.awt.FlowLayout.LEFT, 4, 2));
buildModeButtonGroup.add(viewMode2);
viewMode2.setIcon(getIcon("turn_off"));
viewMode2.setPreferredSize(new java.awt.Dimension(36, 36));
bridgesJPanel.add(viewMode2);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 2;
gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
add(bridgesJPanel, gridBagConstraints);
tunnelsJPanel.setLayout(new java.awt.FlowLayout(
java.awt.FlowLayout.LEFT, 4, 2));
buildModeButtonGroup.add(viewMode3);
viewMode3.setIcon(getIcon("turn_off"));
viewMode3.setPreferredSize(new java.awt.Dimension(36, 36));
tunnelsJPanel.add(viewMode3);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 3;
gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
add(tunnelsJPanel, gridBagConstraints);
stationsJPanel.setLayout(new java.awt.FlowLayout(
java.awt.FlowLayout.LEFT, 4, 2));
buildModeButtonGroup.add(viewMode4);
viewMode4.setIcon(getIcon("turn_off"));
viewMode4.setPreferredSize(new java.awt.Dimension(36, 36));
stationsJPanel.add(viewMode4);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 4;
gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
add(stationsJPanel, gridBagConstraints);
spacer.setLayout(new java.awt.FlowLayout(java.awt.FlowLayout.CENTER, 0,
0));
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 5;
gridBagConstraints.gridwidth = 2;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
add(spacer, gridBagConstraints);
}// GEN-END:initComponents
private void formKeyTyped(java.awt.event.KeyEvent evt) {// GEN-FIRST:event_formKeyTyped
viewMode.doClick();
}// GEN-LAST:event_formKeyTyped
private void formKeyPressed(java.awt.event.KeyEvent evt) {// GEN-FIRST:event_formKeyPressed
viewMode.doClick();
}// GEN-LAST:event_formKeyPressed
private void viewModeActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_viewModeActionPerformed
setVisible(false, false, false, false);
cancelStationPlacement();
setTrackBuilderMode(IGNORE_TRACK);
}// GEN-LAST:event_viewModeActionPerformed
private void bulldozeActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_bulldozeActionPerformed
setVisible(false, false, false, false);
cancelStationPlacement();
setTrackBuilderMode(REMOVE_TRACK);
}// GEN-LAST:event_bulldozeActionPerformed
private void addStationActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_addStationActionPerformed
setVisible(false, false, false, true);
setTrackBuilderMode(BUILD_STATION);
}// GEN-LAST:event_addStationActionPerformed
private void upgradeTrackActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_upgradeTrackActionPerformed
setVisible(true, true, false, false);
cancelStationPlacement();
setTrackBuilderMode(UPGRADE_TRACK);
}// GEN-LAST:event_upgradeTrackActionPerformed
private void addTrackActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_addTrackActionPerformed
setVisible(true, true, true, false);
cancelStationPlacement();
setTrackBuilderMode(BUILD_TRACK);
}// GEN-LAST:event_addTrackActionPerformed
private void setVisible(boolean track, boolean bridges, boolean tunnels,
boolean stations) {
trackJPanel.setVisible(bridges);
bridgesJPanel.setVisible(bridges);
tunnelsJPanel.setVisible(tunnels);
stationsJPanel.setVisible(stations);
}
private void setBuildTrackStrategy() {
ArrayList<Integer> ruleIDs = new ArrayList<Integer>();
ruleIDs.add(selectionSet.get(TrackRule.TrackCategories.track));
ruleIDs.add(selectionSet.get(TrackRule.TrackCategories.bridge));
ruleIDs.add(selectionSet.get(TrackRule.TrackCategories.tunnel));
BuildTrackStrategy bts = BuildTrackStrategy.getMultipleRuleInstance(
ruleIDs, modelRoot.getWorld());
modelRoot.setProperty(ModelRoot.Property.BUILD_TRACK_STRATEGY, bts);
}
private void cancelStationPlacement() {
// Cancel build station mode..
stationBuildModel.getStationCancelAction().actionPerformed(
new ActionEvent(this, ActionEvent.ACTION_PERFORMED, ""));
}
private void setTrackBuilderMode(TrackMoveProducer.BuildMode mode) {
trackMoveProducer.setTrackBuilderMode(mode);
modelRoot.setProperty(ModelRoot.Property.TRACK_BUILDER_MODE, mode);
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JToggleButton addStation;
private javax.swing.JToggleButton addTrack;
private javax.swing.ButtonGroup bridgeButtonGroup;
private javax.swing.JPanel bridgesJPanel;
private javax.swing.ButtonGroup buildModeButtonGroup;
private javax.swing.JPanel buildModeJPanel;
private javax.swing.JToggleButton bulldoze;
private javax.swing.JPanel spacer;
private javax.swing.ButtonGroup stationButtonGroup;
private javax.swing.JPanel stationsJPanel;
private javax.swing.ButtonGroup trackButtonGroup;
private javax.swing.JPanel trackJPanel;
private javax.swing.ButtonGroup tunnelButtonGroup;
private javax.swing.JPanel tunnelsJPanel;
private javax.swing.JToggleButton upgradeTrack;
private javax.swing.JToggleButton viewMode;
private javax.swing.JToggleButton viewMode1;
private javax.swing.JToggleButton viewMode2;
private javax.swing.JToggleButton viewMode3;
private javax.swing.JToggleButton viewMode4;
// End of variables declaration//GEN-END:variables
}

/**
* A JPanel that displays the cargo waiting and demanded at a station - used on
* the select station popup window.
*
* @author Luke
*/
public class CargoWaitingAndDemandedJPanel extends javax.swing.JPanel implements
View {
private static final long serialVersionUID = 3760559784860071476L;
private ReadOnlyWorld world;
private FreerailsPrincipal principal;
public CargoWaitingAndDemandedJPanel() {
initComponents();
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
private void initComponents() {// GEN-BEGIN:initComponents
java.awt.GridBagConstraints gridBagConstraints;
jScrollPane1 = new javax.swing.JScrollPane();
jPanel1 = new javax.swing.JPanel();
stationName = new javax.swing.JLabel();
waiting = new javax.swing.JLabel();
waitingJTable = new javax.swing.JTable();
demands = new javax.swing.JLabel();
demandsJList = new javax.swing.JList();
spacer = new javax.swing.JPanel();
setLayout(new java.awt.GridBagLayout());
setPreferredSize(new java.awt.Dimension(100, 200));
jScrollPane1.setBorder(null);
jScrollPane1
.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
jPanel1.setLayout(new java.awt.GridBagLayout());
stationName.setText("Station Name");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 0;
gridBagConstraints.insets = new java.awt.Insets(6, 6, 6, 6);
gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTH;
jPanel1.add(stationName, gridBagConstraints);
waiting.setText("Waiting");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
jPanel1.add(waiting, gridBagConstraints);
waitingJTable.setBackground(javax.swing.UIManager.getDefaults()
.getColor("Button.background"));
waitingJTable.setFont(new java.awt.Font("Dialog", 0, 10));
waitingJTable.setModel(new javax.swing.table.DefaultTableModel(
new Object[][] { { "Mail", "4" }, { "Passengers", null } },
new String[] { "Title 1", "Title 2" }));
waitingJTable
.setAutoResizeMode(javax.swing.JTable.AUTO_RESIZE_ALL_COLUMNS);
waitingJTable.setFocusable(false);
waitingJTable.setRequestFocusEnabled(false);
waitingJTable.setRowSelectionAllowed(false);
waitingJTable.setShowHorizontalLines(false);
waitingJTable.setShowVerticalLines(false);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 2;
gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
gridBagConstraints.weightx = 1.0;
jPanel1.add(waitingJTable, gridBagConstraints);
demands.setText("Demands");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 3;
gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
jPanel1.add(demands, gridBagConstraints);
demandsJList.setBackground(javax.swing.UIManager.getDefaults()
.getColor("Button.background"));
demandsJList.setFont(new java.awt.Font("Dialog", 0, 10));
demandsJList.setFocusable(false);
demandsJList.setRequestFocusEnabled(false);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 4;
gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
gridBagConstraints.weightx = 1.0;
jPanel1.add(demandsJList, gridBagConstraints);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 5;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
jPanel1.add(spacer, gridBagConstraints);
jScrollPane1.setViewportView(jPanel1);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
add(jScrollPane1, gridBagConstraints);
}// GEN-END:initComponents
public void setup(ModelRoot model, RenderersRoot vl,
Action closeAction) {
this.world = model.getWorld();
this.principal = model.getPrincipal();
}
public void display(int newStationID) {
StationModel station = (StationModel) world.get(principal,
KEY.STATIONS, newStationID);
this.stationName.setText(station.getStationName());
final ImmutableCargoBundle cargoWaiting = (ImmutableCargoBundle) world
.get(principal, KEY.CARGO_BUNDLES, station.getCargoBundleID());
// count the number of cargo types waiting and demanded.
final ArrayList<String> typeWaiting = new ArrayList<String>();
final ArrayList<Integer> quantityWaiting = new ArrayList<Integer>();
final Vector<String> typeDemanded = new Vector<String>();
for (int i = 0; i < world.size(SKEY.CARGO_TYPES); i++) {
CargoType cargoType = (CargoType) world.get(SKEY.CARGO_TYPES, i);
int amountWaiting = cargoWaiting.getAmount(i);
if (0 != amountWaiting) {
typeWaiting.add(cargoType.getDisplayName());
int carloads = amountWaiting
/ WagonType.UNITS_OF_CARGO_PER_WAGON;
quantityWaiting.add(new Integer(carloads));
}
if (station.getDemand().isCargoDemanded(i)) {
typeDemanded.add(cargoType.getDisplayName());
}
}
/*
* The table shows the cargo waiting at the station. First column is
* cargo type; second column is quantity in carloads.
*/
TableModel tableModel = new AbstractTableModel() {
private static final long serialVersionUID = 3760559784860071476L;
public int getRowCount() {
return typeWaiting.size();
}
public int getColumnCount() {
return 2;
}
public Object getValueAt(int row, int column) {
if (0 == column) {
return typeWaiting.get(row);
}
return quantityWaiting.get(row);
}
};
this.waitingJTable.setModel(tableModel);
/* The list shows the cargo demanded by the station. */
this.demandsJList.setListData(typeDemanded);
this.invalidate();
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JLabel demands;
private javax.swing.JList demandsJList;
private javax.swing.JPanel jPanel1;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JPanel spacer;
private javax.swing.JLabel stationName;
private javax.swing.JLabel waiting;
private javax.swing.JTable waitingJTable;
// End of variables declaration//GEN-END:variables
}

/**
* This JLabel shows the amount of cash available.
*
* @author Luke
*
*/
public class CashJLabel extends JLabel implements View {
private static final long serialVersionUID = 3257853181542412341L;
private ReadOnlyWorld w;
private FreerailsPrincipal principal;
public CashJLabel() {
this.setText(" ");
}
public void setup(ModelRoot model, RenderersRoot vl,
Action closeAction) {
this.w = model.getWorld();
principal = model.getPrincipal();
}
@Override
protected void paintComponent(Graphics g) {
if (null != w) {
Money m = w.getCurrentBalance(principal);
String s = m.toString();
this.setText("$" + s);
}
super.paintComponent(g);
}
}

/**
* JPanel that displays confirmation of exiting, used when the exit menu item is
* selected or x is pressed.
*
* @author SonnyZ
*/
public class ConfirmExitJPanel extends javax.swing.JPanel implements View {
private static final long serialVersionUID = 3256728398394110517L;
/** Creates new form ConfirmExitJPanel. */
public ConfirmExitJPanel() {
initComponents();
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
private void initComponents() {// GEN-BEGIN:initComponents
java.awt.GridBagConstraints gridBagConstraints;
jPanel1 = new javax.swing.JPanel();
jLabel1 = new javax.swing.JLabel();
jPanel2 = new javax.swing.JPanel();
confirmExit = new javax.swing.JButton();
closeJButton = new javax.swing.JButton();
setLayout(new java.awt.GridBagLayout());
setPreferredSize(new java.awt.Dimension(240, 140));
jLabel1.setText("Are you sure you want to Exit?");
jLabel1.setHorizontalTextPosition(javax.swing.SwingConstants.LEFT);
jPanel1.add(jLabel1);
add(jPanel1, new java.awt.GridBagConstraints());
jPanel2.setLayout(new java.awt.GridBagLayout());
confirmExit.setText("Exit");
confirmExit.setContentAreaFilled(false);
confirmExit.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
confirmExitActionPerformed(evt);
}
});
jPanel2.add(confirmExit, new java.awt.GridBagConstraints());
closeJButton.setText("Cancel");
jPanel2.add(closeJButton, new java.awt.GridBagConstraints());
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.ipadx = 15;
gridBagConstraints.insets = new java.awt.Insets(3, 0, 0, 0);
add(jPanel2, gridBagConstraints);
}// GEN-END:initComponents
private void confirmExitActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_confirmExitActionPerformed
System.exit(0);
}// GEN-LAST:event_confirmExitActionPerformed
public void setup(ModelRoot mr, RenderersRoot vl,
Action closeAction) {
closeJButton.setAction(closeAction);
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JButton closeJButton;
private javax.swing.JButton confirmExit;
private javax.swing.JLabel jLabel1;
private javax.swing.JPanel jPanel1;
private javax.swing.JPanel jPanel2;
// End of variables declaration//GEN-END:variables
}

/**
* This JLabel shows the current date.
*
* @author Luke
*
*/
public class DateJLabel extends JLabel implements View {
private static final long serialVersionUID = 3689348840578757942L;
private ReadOnlyWorld w;
public DateJLabel() {
this.setText(" ");
}
@Override
protected void paintComponent(Graphics g) {
if (null != w) {
GameTime time = w.currentTime();
GameCalendar gameCalendar = (GameCalendar) w.get(ITEM.CALENDAR);
String s = gameCalendar.getYearAndMonth(time.getTicks());
super.setText(s);
}
super.paintComponent(g);
}
public void setup(ModelRoot model, RenderersRoot vl,
Action closeAction) {
this.w = model.getWorld();
}
}

/**
* Draws the main map, that is the terrain, track, trains, station names etc.
*
* @author Luke
*/
public class DetailMapRenderer implements MapRenderer {
private static final boolean OSXWorkaround = (System
.getProperty("OSXWorkaround") != null);
private final MapLayerRenderer background;
private final Dimension mapSizeInPixels;
private final OverHeadTrainView trainsview;
private final StationRadiusRenderer stationRadius;
private final BuildTrackRenderer buildTrackRenderer;
private final BuildTrackController buildTrackController;
private final Painter stationBoxes;
public DetailMapRenderer(ReadOnlyWorld world, RenderersRoot rr,
ModelRoot modelRoot) {
trainsview = new OverHeadTrainView(world, rr, modelRoot);
MapBackgroundRender render = new MapBackgroundRender(world, rr,
modelRoot);
if (OSXWorkaround) {
// Don't buffer the mapviews background.
background = render;
} else {
background = new SquareTileBackgroundRenderer(render);
}
Dimension mapSize = new Dimension(world.getMapWidth(), world
.getMapHeight());
mapSizeInPixels = new Dimension(mapSize.width * Constants.TILE_SIZE,
mapSize.height * Constants.TILE_SIZE);
stationRadius = new StationRadiusRenderer(modelRoot);
buildTrackRenderer = new BuildTrackRenderer(rr, modelRoot);
buildTrackController = new BuildTrackController(world, modelRoot);
stationBoxes = new StationBoxRenderer(world, rr, modelRoot);
}
public StationRadiusRenderer getStationRadius() {
return stationRadius;
}
public BuildTrackController getBuildTrackController() {
return buildTrackController;
}
public float getScale() {
return Constants.TILE_SIZE;
}
public Dimension getMapSizeInPixels() {
return mapSizeInPixels;
}
public TrainRenderer getTrainRenderer() {
return this.trainsview.getTrainRenderer();
}
public void paintTile(Graphics g, int tileX, int tileY) {
background.paintTile(g, tileX, tileY);
trainsview.paint((Graphics2D) g);
stationRadius.paint((Graphics2D) g);
stationBoxes.paint((Graphics2D) g);
buildTrackRenderer.paint((Graphics2D) g);
}
public void refreshTile(int x, int y) {
background.refreshTile(x, y);
}
public void paintRect(Graphics g, Rectangle visibleRect) {
background.paintRect(g, visibleRect);
trainsview.paint((Graphics2D) g);
stationRadius.paint((Graphics2D) g);
stationBoxes.paint((Graphics2D) g);
buildTrackRenderer.paint((Graphics2D) g);
}
public void refreshAll() {
background.refreshAll();
}
}

/**
* This class is responsible for displaying dialogue boxes, adding borders to
* them as appropriate, and returning focus to the last focus owner after a
* dialogue box has been closed. It is also responsible for adding components
* that need to update in response to moves to the MoveChainFork. Currently
* dialogue boxes are not separate windows. Instead, they are drawn on the modal
* layer of the main JFrames LayerPlane. This allows dialogue boxes with
* transparent regions to be used.
*
* @author lindsal8
* @author smackay
*/
public class DialogueBoxController implements WorldListListener {
private static final Logger logger = Logger
.getLogger(DialogueBoxController.class.getName());
private final JButton closeButton = new JButton("Close");
private SelectEngineJPanel selectEngine;
private final MyGlassPanel glassPanel;
private NewsPaperJPanel newspaper;
private SelectWagonsJPanel selectWagons;
private HtmlJPanel showControls;
private HtmlJPanel about;
private HtmlJPanel how2play;
private HtmlJPanel javaProperties;
private TerrainInfoJPanel terrainInfo;
private StationInfoJPanel stationInfo;
private TrainDialogueJPanel trainDialogueJPanel;
private ReadOnlyWorld world;
private ModelRootImpl modelRoot;
private RenderersRoot vl;
private Component defaultFocusOwner = null;
private final JFrame frame;
private JInternalFrame dialogueJInternalFrame;
/**
* Use this Action to close a dialogue without performing any other
* action.
*/
private final Action closeCurrentDialogue = new AbstractAction("Close") {
private static final long serialVersionUID = 1L;
public void actionPerformed(ActionEvent arg0) {
closeContent();
}
};
private final Action selectEngineAction = new AbstractAction() {
private static final long serialVersionUID = 1L;
public void actionPerformed(ActionEvent arg0) {
showSelectWagons();
}
};
private final ActionListener trainDetailsButtonActionListener = new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
showTrainList();
}
};
private final Action selectWagonsAction = new AbstractAction("Next") {
private static final long serialVersionUID = 1L;
public void actionPerformed(ActionEvent arg0) {
WorldIterator wi = new NonNullElements(KEY.STATIONS, modelRoot
.getWorld(), modelRoot.getPrincipal());
if (wi.next()) {
StationModel station = (StationModel) wi.getElement();
ImList<PlannedTrain> before = station.getProduction();
int engineType = selectEngine.getEngineType();
int[] wagonTypes = selectWagons.getWagons();
ImList<PlannedTrain> after = new ImList<PlannedTrain>(
new PlannedTrain(engineType, wagonTypes));
Move m = new ChangeProductionAtEngineShopMove(before, after, wi
.getIndex(), modelRoot.getPrincipal());
modelRoot.doMove(m);
}
closeContent();
}
};
public DialogueBoxController(JFrame frame, ModelRootImpl mr) {
this.frame = frame;
modelRoot = mr;
// Setup glass panel..
glassPanel = new MyGlassPanel();
glassPanel.setSize(frame.getSize());
frame.getLayeredPane().add(glassPanel, JLayeredPane.MODAL_LAYER);
glassPanel.revalidate();
glassPanel.setVisible(false);
// We need to resize the glass panel when its parent resizes.
frame.getLayeredPane().addComponentListener(
new java.awt.event.ComponentAdapter() {
@Override
public void componentResized(
java.awt.event.ComponentEvent evt) {
glassPanel.setSize(glassPanel.getParent().getSize());
glassPanel.revalidate();
}
});
closeButton.addActionListener(closeCurrentDialogue);
showControls = new HtmlJPanel(DialogueBoxController.class
.getResource("/jfreerails/client/view/game_controls.html"));
about = new HtmlJPanel(DialogueBoxController.class
.getResource("/jfreerails/client/view/about.htm"));
how2play = new HtmlJPanel(DialogueBoxController.class
.getResource("/jfreerails/client/view/how_to_play.htm"));
terrainInfo = new TerrainInfoJPanel();
stationInfo = new StationInfoJPanel();
javaProperties = new HtmlJPanel(ShowJavaProperties
.getPropertiesHtmlString());
Dimension d = javaProperties.getPreferredSize();
d.width += 50;
javaProperties.setPreferredSize(d);
newspaper = new NewsPaperJPanel();
selectWagons = new SelectWagonsJPanel();
selectEngine = new SelectEngineJPanel();
trainDialogueJPanel = new TrainDialogueJPanel();
}
/**
* Called when a new game is started or a game is loaded.
* <p>
* <b>Be extremely careful with the references of objects allocated in this
* method to avoid memory leaks - see bug 967677 (OutOfMemoryError after
* starting several new games). </b>
* </p>
*/
public void setup(ModelRootImpl mr, RenderersRoot vl) {
this.modelRoot = mr;
this.vl = vl;
modelRoot.addListListener(this); // When a new train gets built, we
// show the train info etc
this.world = modelRoot.getWorld();
if (world == null)
throw new NullPointerException();
if (vl == null)
throw new NullPointerException();
// Setup the various dialogue boxes.
// setup the terrain info dialogue.
terrainInfo.setup(world, vl);
// setup the supply and demand at station dialogue.
stationInfo.setup(modelRoot, vl, this.closeCurrentDialogue);
modelRoot.addListListener(stationInfo);
// setup the 'show controls' dialogue
showControls.setup(this.modelRoot, vl, this.closeCurrentDialogue);
about.setup(this.modelRoot, vl, this.closeCurrentDialogue);
how2play.setup(this.modelRoot, vl, this.closeCurrentDialogue);
javaProperties.setup(this.modelRoot, vl, this.closeCurrentDialogue);
// Set up train orders dialogue
// trainScheduleJPanel = new TrainScheduleJPanel();
// trainScheduleJPanel.setup(w, vl);
// moveChainFork.add(trainScheduleJPanel);
// Set up select engine dialogue.
selectEngine.setCancelButtonActionListener(this.closeCurrentDialogue);
selectEngine.setup(modelRoot, vl, selectEngineAction);
newspaper.setup(modelRoot, vl, closeCurrentDialogue);
selectWagons.setup(modelRoot, vl, selectWagonsAction);
trainDialogueJPanel.setup(modelRoot, vl, this.closeCurrentDialogue);
modelRoot.addListListener(trainDialogueJPanel);
trainDialogueJPanel
.setTrainDetailsButtonActionListener(trainDetailsButtonActionListener);
trainDialogueJPanel
.setCancelButtonActionListener(this.closeCurrentDialogue);
}
public void showSaveGame(){
SaveGameJPanel saveGameJPanel = new SaveGameJPanel();
saveGameJPanel.setup(modelRoot, vl, this.closeCurrentDialogue);
showContent(saveGameJPanel);
}
public void showSelectSavedGame2Load(){
Message2Server refreshGames = new RefreshListOfGamesMessage2Server(2);
modelRoot.sendCommand(refreshGames);
LoadGameJPanel loadGameJPane = new LoadGameJPanel();
loadGameJPane.setup(modelRoot, vl, this.closeCurrentDialogue);
showContent(loadGameJPane);
}
public void showTrainOrders() {
WorldIterator wi = new NonNullElements(KEY.TRAINS, world, modelRoot
.getPrincipal());
if (!wi.next()) {
modelRoot.setProperty(Property.QUICK_MESSAGE, "Cannot"
+ " show train orders since there are no" + " trains!");
} else {
trainDialogueJPanel.display(wi.getIndex());
this.showContent(trainDialogueJPanel);
}
}
public void showSelectEngine() {
WorldIterator wi = new NonNullElements(KEY.STATIONS, world, modelRoot
.getPrincipal());
if (!wi.next()) {
modelRoot.setProperty(Property.QUICK_MESSAGE, "Can't"
+ " build train since there are no stations");
} else {
showContent(selectEngine);
}
}
public void showGameControls() {
showContent(this.showControls);
}
public void showIncomeStatement() {
IncomeStatementHtmlJPanel bs = new IncomeStatementHtmlJPanel();
bs.setup(this.modelRoot, vl, this.closeCurrentDialogue);
this.showContent(bs);
}
public void showBalanceSheet() {
BalanceSheetHtmlJPanel bs = new BalanceSheetHtmlJPanel();
bs.setup(this.modelRoot, vl, this.closeCurrentDialogue);
this.showContent(bs);
}
public void showReportBug(){
CopyableTextJPanel ct = new CopyableTextJPanel();
ct.setText(ReportBugTextGenerator.genText());
showContent(ct);
}
public void showBrokerScreen() {
// this is Creating a BrokerScreen Internal Frame in the Main Frame
BrokerScreenHtmlJFrame brokerScreenHtmlJFrame = new BrokerScreenHtmlJFrame();
brokerScreenHtmlJFrame.setup(this.modelRoot, vl,
this.closeCurrentDialogue);
brokerScreenHtmlJFrame.setFrameIcon(null);
showContent(brokerScreenHtmlJFrame);
}
// Shows the Exit Dialog -- @author SonnyZ
public void showExitDialog() {
ConfirmExitJPanel bs = new ConfirmExitJPanel();
bs.setup(this.modelRoot, vl, this.closeCurrentDialogue);
this.showContent(bs);
}
public void showAbout() {
showContent(this.about);
}
public void showHow2Play() {
showContent(this.how2play);
}
public void showJavaProperties() {
showContent(javaProperties);
}
public void showSelectWagons() {
selectWagons.resetSelectedWagons();
selectWagons.setEngineType(selectEngine.getEngineType());
showContent(selectWagons);
}
public void showTerrainInfo(int terrainType) {
this.terrainInfo.setTerrainType(terrainType);
showContent(terrainInfo);
}
public void showTerrainInfo(int x, int y) {
FreerailsTile tile = (FreerailsTile) world.getTile(x, y);
int terrainType = tile.getTerrainTypeID();
showTerrainInfo(terrainType);
}
public void showStationInfo(int stationNumber) {
try {
stationInfo.setStation(stationNumber);
showContent(stationInfo);
} catch (NoSuchElementException e) {
logger.warning("Station " + stationNumber + " does not exist!");
}
}
public void showTrainOrders(int trainId) {
closeContent();
if (trainId != -1) {
trainDialogueJPanel.display(trainId);
showContent(trainDialogueJPanel);
}
}
public void showTrainList() {
if (world.size(modelRoot.getPrincipal(), KEY.TRAINS) > 0) {
final TrainListJPanel trainList = new TrainListJPanel();
trainList.setup(modelRoot, vl, closeCurrentDialogue);
trainList.setShowTrainDetailsActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
int id = trainList.getSelectedTrainID();
showTrainOrders(id);
}
});
showContent(trainList);
} else {
modelRoot.setProperty(Property.QUICK_MESSAGE, "There are"
+ " no trains to display!");
}
}
public void showNetworthGraph() {
final NetWorthGraphJPanel worthGraph = new NetWorthGraphJPanel();
worthGraph.setup(modelRoot, vl, closeCurrentDialogue);
showContent(worthGraph);
}
public void showLeaderBoard() {
LeaderBoardJPanel leaderBoardJPanel = new LeaderBoardJPanel();
leaderBoardJPanel.setup(modelRoot, vl, closeCurrentDialogue);
showContent(leaderBoardJPanel);
}
public void showContent(JComponent component) {
closeContent();
JComponent contentPanel;
if (component instanceof JInternalFrame) {
dialogueJInternalFrame = (JInternalFrame) component;
} else {
if (!(component instanceof View)) {
contentPanel = new javax.swing.JPanel();
contentPanel.setLayout(new java.awt.GridBagLayout());
GridBagConstraints constraints = new GridBagConstraints();
constraints.gridx = 0;
constraints.gridy = 0;
constraints.weightx = 1.0;
constraints.weighty = 1.0;
constraints.insets = new Insets(7, 7, 7, 7);
contentPanel.add(component, constraints);
constraints = new GridBagConstraints();
constraints.gridx = 0;
constraints.gridy = 1;
constraints.insets = new Insets(7, 7, 7, 7);
contentPanel.add(closeButton, constraints);
} else {
contentPanel = component;
}
dialogueJInternalFrame = new JInternalFrame();
dialogueJInternalFrame.setFrameIcon(null);
dialogueJInternalFrame.getContentPane().add(contentPanel);
dialogueJInternalFrame.pack();
}
/*
* Make sure the size of the dialogue does not exceed the size of the
* frames content pane.
*/
int parentWidth = frame.getContentPane().getWidth();
int parentHeight = frame.getContentPane().getHeight();
Dimension size = dialogueJInternalFrame.getSize();
if (size.width > parentWidth) {
size.width = parentWidth;
}
if (size.height > parentHeight) {
size.height = parentHeight;
}
dialogueJInternalFrame.setSize(size);
dialogueJInternalFrame.setLocation(
(frame.getWidth() - dialogueJInternalFrame.getWidth()) / 2,
(frame.getHeight() - dialogueJInternalFrame.getHeight()) / 2);
frame.getLayeredPane().add(dialogueJInternalFrame,
JLayeredPane.MODAL_LAYER);
dialogueJInternalFrame.setVisible(true);
}
public void closeContent() {
if (null != dialogueJInternalFrame) {
dialogueJInternalFrame.setVisible(false);
frame.getLayeredPane().remove(dialogueJInternalFrame);
dialogueJInternalFrame.dispose();
}
if (null != defaultFocusOwner) {
defaultFocusOwner.requestFocus();
}
}
public void setDefaultFocusOwner(Component defaultFocusOwner) {
this.defaultFocusOwner = defaultFocusOwner;
}
public void showStationOrTerrainInfo(int x, int y) {
FreerailsTile tile = (FreerailsTile) world.getTile(x, y);
TrackRule trackRule = tile.getTrackPiece().getTrackRule();
FreerailsPrincipal principal = modelRoot.getPrincipal();
if (trackRule.isStation()
&& tile.getTrackPiece().getOwnerID() == world.getID(principal)) {
for (int i = 0; i < world.size(principal, KEY.STATIONS); i++) {
StationModel station = (StationModel) world.get(principal,
KEY.STATIONS, i);
if (null != station && station.x == x && station.y == y) {
this.showStationInfo(i);
return;
}
}
throw new IllegalStateException("Couldn't find station at " + x
+ ", " + y);
}
this.showTerrainInfo(x, y);
}
public void listUpdated(KEY key, int index, FreerailsPrincipal principal) {
// do nothing
}
public void itemAdded(KEY key, int index, FreerailsPrincipal principal) {
/*
* Fix for: 910138 After building a train display train orders 910143
* After building station show supply and demand
*/
boolean rightPrincipal = principal
.equals(this.modelRoot.getPrincipal());
if (KEY.TRAINS == key && rightPrincipal) {
this.showTrainOrders(index);
} else if (KEY.STATIONS == key && rightPrincipal) {
this.showStationInfo(index);
}
}
public void itemRemoved(KEY key, int index, FreerailsPrincipal principal) {
// do nothing
}
}

/**
* ComboBoxModel that provides access to the screen resolutions and bit depths
* available.
*
* @author Luke Lindsay
*/
public class DisplayModesComboBoxModels implements javax.swing.ComboBoxModel {
private final GraphicsConfiguration defaultConfiguration = GraphicsEnvironment
.getLocalGraphicsEnvironment().getDefaultScreenDevice()
.getDefaultConfiguration();
private final ArrayList<MyDisplayMode> modes = new ArrayList<MyDisplayMode>();
private MyDisplayMode selection;
public DisplayModesComboBoxModels() {
DisplayMode currentMode = defaultConfiguration.getDevice()
.getDisplayMode();
selection = new MyDisplayMode(currentMode);
DisplayMode[] displayModes = defaultConfiguration.getDevice()
.getDisplayModes();
for (int i = 0; i < displayModes.length; i++) {
MyDisplayMode mode = new MyDisplayMode(displayModes[i]);
modes.add(mode);
}
}
/**
* Permanently removes from the list in this object any display modes with
* width, height, or bitdepth below the specified values.
*/
public void removeDisplayModesBelow(int width, int height, int bitdepth) {
Iterator<MyDisplayMode> it = modes.iterator();
while (it.hasNext()) {
MyDisplayMode mode = it.next();
DisplayMode displayMode = mode.displayMode;
final boolean tooNarrow = displayMode.getWidth() < width;
final boolean tooShort = displayMode.getHeight() < height;
/*
* Note, displayMode.getBitDepth() may return
* DisplayMode.BIT_DEPTH_MULTI, which is -1.
*/
final boolean tooFewColours = (displayMode.getBitDepth() < bitdepth)
&& (displayMode.getBitDepth() != DisplayMode.BIT_DEPTH_MULTI);
if (tooNarrow || tooShort || tooFewColours) {
it.remove();
}
}
}
public Object getSelectedItem() {
return selection;
}
public void setSelectedItem(Object anItem) {
selection = (MyDisplayMode) anItem;
}
public void addListDataListener(javax.swing.event.ListDataListener l) {
}
public MyDisplayMode getElementAt(int index) {
return modes.get(index);
}
public int getSize() {
return modes.size();
}
public void removeListDataListener(javax.swing.event.ListDataListener l) {
}
}

/**
* Paints the cursor on the map, note the cursor's position is stored on the
* ModelRoot under the key CURSOR_POSITION.
*
* @author Luke
*/
final public class FreerailsCursor {
private final Image buildTrack, upgradeTrack, removeTrack, infoMode;
private final ModelRoot modelRoot;
/** The location of the cursor last time paintCursor(.) was called. */
private ImPoint lastCursorPosition = new ImPoint();
/** The time in ms the cursor arrived at its current position. */
private long timeArrived = 0;
/**
* Creates a new FreerailsCursor.
*
* @throws IOException
*/
public FreerailsCursor(ModelRoot mr, RenderersRoot rr) throws IOException {
this.modelRoot = mr;
modelRoot.setProperty(ModelRoot.Property.CURSOR_MESSAGE, null);
buildTrack = rr.getImage("cursor/buildtrack.png");
upgradeTrack = rr.getImage("cursor/upgradetrack.png");
removeTrack = rr.getImage("cursor/removetrack.png");
infoMode = rr.getImage("cursor/infomode.png");
}
/**
* Paints the cursor. The method calculates position to paint it based on
* the tile size and the cursor's map position.
*
* @param g
* The graphics object to paint the cursor on.
* @param tileSize
* The dimensions of a tile.
*/
public void paintCursor(Graphics g, Dimension tileSize) {
Graphics2D g2 = (Graphics2D) g;
TrackMoveProducer.BuildMode buildMode = (TrackMoveProducer.BuildMode) modelRoot
.getProperty(ModelRoot.Property.TRACK_BUILDER_MODE);
ImPoint cursorMapPosition = (ImPoint) modelRoot
.getProperty(ModelRoot.Property.CURSOR_POSITION);
/* Has the cursor moved since we last painted it? */
if (!cursorMapPosition.equals(lastCursorPosition)) {
lastCursorPosition = cursorMapPosition;
timeArrived = System.currentTimeMillis();
}
int x = cursorMapPosition.x * tileSize.width;
int y = cursorMapPosition.y * tileSize.height;
Image cursor = null;
switch (buildMode) {
case BUILD_TRACK:
cursor = buildTrack;
break;
case REMOVE_TRACK:
cursor = removeTrack;
break;
case UPGRADE_TRACK:
cursor = upgradeTrack;
break;
case IGNORE_TRACK:
cursor = infoMode;
break;
case BUILD_STATION:
cursor = buildTrack;
break;
}
Boolean b = (Boolean) modelRoot
.getProperty(ModelRoot.Property.IGNORE_KEY_EVENTS);
long time = System.currentTimeMillis() - timeArrived;
boolean show = ((time / 500) % 2) == 0;
if (show && !b.booleanValue()) {
g.drawImage(cursor, x, y, null);
}
// Second, draw a message below the cursor if appropriate.
String message = (String) modelRoot
.getProperty(ModelRoot.Property.CURSOR_MESSAGE);
if (null != message && !message.equals("")) {
int fontSize = 12;
Font font = new Font("Arial", 0, fontSize);
FontRenderContext frc = g2.getFontRenderContext();
TextLayout layout = new TextLayout(message, font, frc);
// We want the message to be centered below the cursor.
float visibleAdvance = layout.getVisibleAdvance();
float textX = (x + (tileSize.width / 2) - (visibleAdvance / 2));
float textY = y + tileSize.height + fontSize + 5;
g.setColor(java.awt.Color.white);
layout.draw(g2, textX, textY);
}
// Draw a big white dot at the target point.
ImPoint targetPoint = (ImPoint) modelRoot
.getProperty(ModelRoot.Property.THINKING_POINT);
if (null != targetPoint) {
time = System.currentTimeMillis();
int dotSize;
if ((time % 500) > 250) {
dotSize = BuildTrackRenderer.BIG_DOT_WIDTH;
} else {
dotSize = BuildTrackRenderer.SMALL_DOT_WIDTH;
}
g.setColor(Color.WHITE);
x = targetPoint.x * tileSize.width + (tileSize.width - dotSize) / 2;
y = targetPoint.y * tileSize.width + (tileSize.height - dotSize)
/ 2;
g.fillOval(x, y, dotSize, dotSize);
}
}
}

/**
* This JPanel displays a HTML document read from a URL.
*
* @author Luke
*/
public class HtmlJPanel extends javax.swing.JPanel implements View {
private static final long serialVersionUID = 4120848850266371126L;
private static final Logger logger = Logger.getLogger(HtmlJPanel.class
.getName());
HtmlJPanel() {
initComponents();
}
public HtmlJPanel(URL url) {
initComponents();
setHtml(loadText(url));
}
public HtmlJPanel(URL url, HashMap context) {
initComponents();
String template = loadText(url);
String populatedTemplate = populateTokens(template, context);
setHtml(populatedTemplate);
}
public HtmlJPanel(String html) {
initComponents();
setHtml(html);
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
private void initComponents() {// GEN-BEGIN:initComponents
java.awt.GridBagConstraints gridBagConstraints;
jScrollPane1 = new javax.swing.JScrollPane();
htmlJLabel = new javax.swing.JLabel();
done = new javax.swing.JButton();
setLayout(new java.awt.GridBagLayout());
setMinimumSize(new java.awt.Dimension(400, 300));
jScrollPane1
.setVerticalScrollBarPolicy(javax.swing.ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
htmlJLabel.setFont(new java.awt.Font("Dialog", 0, 12));
htmlJLabel.setVerticalTextPosition(javax.swing.SwingConstants.TOP);
jScrollPane1.setViewportView(htmlJLabel);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
gridBagConstraints.insets = new java.awt.Insets(7, 7, 7, 7);
add(jScrollPane1, gridBagConstraints);
done.setText("Close");
done.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
doneActionPerformed(evt);
}
});
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.insets = new java.awt.Insets(7, 7, 7, 7);
add(done, gridBagConstraints);
}// GEN-END:initComponents
private void doneActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_doneActionPerformed
// TODO add your handling code here:
}// GEN-LAST:event_doneActionPerformed
public void setup(ModelRoot m, RenderersRoot vl,
Action closeAction) {
this.done.setAction(closeAction);
}
/** Load the help text from file. */
String loadText(final URL htmlUrl) {
try {
InputStream in = htmlUrl.openStream();
BufferedReader br = new BufferedReader(new InputStreamReader(
new DataInputStream(in)));
String line;
String text = "";
while ((line = br.readLine()) != null) {
text = text + line;
}
return text;
} catch (Exception e) {
e.printStackTrace();
logger.warning(htmlUrl.toString());
return "Couldn't read: " + htmlUrl;
}
}
void setHtml(String s) {
htmlJLabel.setText(s);
}
static String populateTokens(String template, Object context) {
StringTokenizer tokenizer = new StringTokenizer(template, "$");
String output = "";
while (tokenizer.hasMoreTokens()) {
output += tokenizer.nextToken();
if (tokenizer.hasMoreTokens()) {
String token = tokenizer.nextToken();
String value;
if (context instanceof HashMap) {
value = (String) ((HashMap) context).get(token);
} else {
try {
StringTokenizer t2 = new StringTokenizer(token, ".");
value = null;
Object o = context;
while (t2.hasMoreTokens()) {
String subToken = t2.nextToken();
Field field = o.getClass().getField(subToken);
o = field.get(o);
}
value = o.toString();
} catch (Exception e) {
e.printStackTrace();
throw new NoSuchElementException(token);
}
}
output += value;
}
}
return output;
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JButton done;
private javax.swing.JLabel htmlJLabel;
private javax.swing.JScrollPane jScrollPane1;
// End of variables declaration//GEN-END:variables
}

/**
* Generates the income statement- note, its fields are read using reflection so
* don't change their names.
*
* @author Luke
*
*/
public class IncomeStatementGenerator {
GameTime from;
GameTime to;
final ReadOnlyWorld w;
final FreerailsPrincipal principal;
private int startyear = 0;
private GameCalendar cal;
public Money mailTotal;
public Money passengersTotal;
public Money fastFreightTotal;
public Money slowFreightTotal;
public Money bulkFreightTotal;
public Money interestTotal;
public Money trainMaintenanceTotal;
public Money trackMaintenanceTotal;
public Money stationMaintenanceTotal;
public Money profitTotal;
public Money mailYtd;
public Money passengersYtd;
public Money fastFreightYtd;
public Money slowFreightYtd;
public Money bulkFreightYtd;
public Money interestYtd;
public Money trainMaintenanceYtd;
public Money trackMaintenanceYtd;
public Money stationMaintenanceYtd;
public Money profitYtd;
public String year;
IncomeStatementGenerator(ReadOnlyWorld w, FreerailsPrincipal principal) {
this.w = w;
this.principal = principal;
cal = (GameCalendar) w.get(ITEM.CALENDAR);
// Income from cargo delivery
mailTotal = calRevenue(Categories.Mail);
passengersTotal = calRevenue(Categories.Passengers);
fastFreightTotal = calRevenue(Categories.Fast_Freight);
slowFreightTotal = calRevenue(Categories.Slow_Freight);
bulkFreightTotal = calRevenue(Categories.Bulk_Freight);
// Expenses.
interestTotal = calTotal(INTEREST_CHARGE);
trainMaintenanceTotal = calTotal(TRAIN_MAINTENANCE);
trackMaintenanceTotal = calTotal(TRACK_MAINTENANCE);
stationMaintenanceTotal = calTotal(STATION_MAINTENANCE);
/*
* Note, expenses are stored as negative values so we just add
* everything up.
*/
long profit = mailTotal.getAmount() + passengersTotal.getAmount()
+ fastFreightTotal.getAmount() + slowFreightTotal.getAmount()
+ bulkFreightTotal.getAmount() + interestTotal.getAmount()
+ trainMaintenanceTotal.getAmount()
+ trackMaintenanceTotal.getAmount()
+ stationMaintenanceTotal.getAmount();
profitTotal = new Money(profit);
GameTime time = w.currentTime();
startyear = cal.getYear(time.getTicks());
year = String.valueOf(startyear);
// Income from cargo delivery
mailYtd = calRevenue(Categories.Mail);
passengersYtd = calRevenue(Categories.Passengers);
fastFreightYtd = calRevenue(Categories.Fast_Freight);
slowFreightYtd = calRevenue(Categories.Slow_Freight);
bulkFreightYtd = calRevenue(Categories.Bulk_Freight);
// Expenses.
interestYtd = calTotal(INTEREST_CHARGE);
trainMaintenanceYtd = calTotal(TRAIN_MAINTENANCE);
trackMaintenanceYtd = calTotal(TRACK_MAINTENANCE);
stationMaintenanceYtd = calTotal(STATION_MAINTENANCE);
/*
* Note, expenses are stored as negative values so we just add
* everything up.
*/
profit = mailYtd.getAmount() + passengersYtd.getAmount()
+ fastFreightYtd.getAmount() + slowFreightYtd.getAmount()
+ bulkFreightYtd.getAmount() + interestYtd.getAmount()
+ trainMaintenanceYtd.getAmount()
+ trackMaintenanceYtd.getAmount()
+ stationMaintenanceYtd.getAmount();
profitYtd = new Money(profit);
}
/** Calculates the total revenue from the specified cargo type. */
Money calRevenue(Categories cargoCategory) {
long amount = 0;
for (int i = 0; i < w.getNumberOfTransactions(this.principal); i++) {
Transaction t = w.getTransaction(principal, i);
GameTime time = w.getTransactionTimeStamp(principal, i);
if (t instanceof DeliverCargoReceipt
&& cal.getYear(time.getTicks()) >= this.startyear) {
DeliverCargoReceipt dcr = (DeliverCargoReceipt) t;
int cargoType = dcr.getCb().getCargoType();
CargoType ct = (CargoType) w.get(SKEY.CARGO_TYPES, cargoType);
if (ct.getCategory().equals(cargoCategory)) {
amount += dcr.deltaCash().getAmount();
}
}
}
return new Money(amount);
}
Money calTrainRevenue(int trainId) {
long amount = 0;
for (int i = 0; i < w.getNumberOfTransactions(this.principal); i++) {
Transaction t = w.getTransaction(principal, i);
GameTime time = w.getTransactionTimeStamp(principal, i);
if (t instanceof DeliverCargoReceipt
&& cal.getYear(time.getTicks()) >= this.startyear) {
DeliverCargoReceipt dcr = (DeliverCargoReceipt) t;
if (dcr.getTrainId() == trainId) {
amount += dcr.deltaCash().getAmount();
}
}
}
return new Money(amount);
}
private Money calTotal(Transaction.Category transactionCategory) {
long amount = 0;
for (int i = 0; i < w.getNumberOfTransactions(this.principal); i++) {
Transaction t = w.getTransaction(principal, i);
GameTime time = w.getTransactionTimeStamp(principal, i);
if (t.getCategory() == transactionCategory
&& cal.getYear(time.getTicks()) >= this.startyear) {
amount += t.deltaCash().getAmount();
}
}
return new Money(amount);
}
}

/**
* A HtmlJPanel that displays the income statement.
*
* @author Luke
*
*/
public class IncomeStatementHtmlJPanel extends HtmlJPanel implements View {
private static final long serialVersionUID = 3257846588885120057L;
private String template;
private int lastNumTransactions = 0;
private ModelRoot modelRoot;
public IncomeStatementHtmlJPanel() {
super();
URL url = IncomeStatementHtmlJPanel.class
.getResource("/jfreerails/client/view/income_statement.htm");
template = loadText(url);
}
@Override
public void setup(ModelRoot modelRoot, RenderersRoot vl,
Action closeAction) {
super.setup(modelRoot, vl, closeAction);
this.modelRoot = modelRoot;
updateHtml();
}
private void updateHtml() {
ReadOnlyWorld world = modelRoot.getWorld();
FreerailsPrincipal playerPrincipal = modelRoot.getPrincipal();
IncomeStatementGenerator balanceSheetGenerator = new IncomeStatementGenerator(
world, playerPrincipal);
String populatedTemplate = populateTokens(template,
balanceSheetGenerator);
setHtml(populatedTemplate);
}
@Override
protected void paintComponent(Graphics g) {
/* Check to see if the text needs updating before painting. */
ReadOnlyWorld world = modelRoot.getWorld();
FreerailsPrincipal playerPrincipal = modelRoot.getPrincipal();
int currentNumberOfTransactions = world
.getNumberOfTransactions(playerPrincipal);
if (currentNumberOfTransactions != lastNumTransactions) {
updateHtml();
}
super.paintComponent(g);
}
}

/**
* Maps keys to OneTileMoveVectors.
*
* @author Luke
*
*/
public class KeyCode2OneTileMoveVector {
private static final HashMap<Integer, Step> keycode2vector = new HashMap<Integer, Step>();
static {
// Set up key mappings...
// Num pad with num lock on
keycode2vector.put(new Integer(KeyEvent.VK_NUMPAD1), Step.SOUTH_WEST);
keycode2vector.put(new Integer(KeyEvent.VK_NUMPAD2), Step.SOUTH);
keycode2vector.put(new Integer(KeyEvent.VK_NUMPAD3), Step.SOUTH_EAST);
keycode2vector.put(new Integer(KeyEvent.VK_NUMPAD4), Step.WEST);
keycode2vector.put(new Integer(KeyEvent.VK_NUMPAD6), Step.EAST);
keycode2vector.put(new Integer(KeyEvent.VK_NUMPAD7), Step.NORTH_WEST);
keycode2vector.put(new Integer(KeyEvent.VK_NUMPAD8), Step.NORTH);
keycode2vector.put(new Integer(KeyEvent.VK_NUMPAD9), Step.NORTH_EAST);
// Num pad with num lock off
keycode2vector.put(new Integer(KeyEvent.VK_END), Step.SOUTH_WEST);
keycode2vector.put(new Integer(KeyEvent.VK_DOWN), Step.SOUTH);
keycode2vector.put(new Integer(KeyEvent.VK_PAGE_DOWN), Step.SOUTH_EAST);
keycode2vector.put(new Integer(KeyEvent.VK_LEFT), Step.WEST);
keycode2vector.put(new Integer(KeyEvent.VK_RIGHT), Step.EAST);
keycode2vector.put(new Integer(KeyEvent.VK_HOME), Step.NORTH_WEST);
keycode2vector.put(new Integer(KeyEvent.VK_UP), Step.NORTH);
keycode2vector.put(new Integer(KeyEvent.VK_PAGE_UP), Step.NORTH_EAST);
}
/** Returns the OneTileMoveVector that is mapped to the specified keycode. */
public static Step getInstanceMappedToKey(int keycode)
throws NoSuchElementException {
Integer integer = new Integer(keycode);
if (!keycode2vector.containsKey(integer)) {
throw new NoSuchElementException(String.valueOf(keycode));
}
return keycode2vector.get(integer);
}
}

/**
* A JPanel that displays the details of the players ordered by net worth.
*
* @author Luke
*/
public class LeaderBoardJPanel extends JPanel implements View {
private static final long serialVersionUID = 3258131375298066229L;
private JList playersList = null;
private ActionListener submitButtonCallBack = null;
private Vector<PlayerDetails> values;
/**
* This method initializes
*/
public LeaderBoardJPanel() {
super();
values = new Vector<PlayerDetails>();
Random rand = new Random();
for (int i = 0; i < 5; i++) {
PlayerDetails p = new PlayerDetails();
p.networth = new Money(rand.nextInt(100));
values.add(p);
}
initialize();
}
/**
* This method initializes this
*/
private void initialize() {
this.add(getPlayersList(), null);
java.awt.event.MouseAdapter mouseAdapter = new java.awt.event.MouseAdapter() {
@Override
public void mouseClicked(java.awt.event.MouseEvent e) {
if (null == submitButtonCallBack) {
System.err.println("mouseClicked");
} else {
submitButtonCallBack.actionPerformed(new ActionEvent(
this, 0, null));
}
}
};
this.addMouseListener(mouseAdapter);
this.playersList.addMouseListener(mouseAdapter);
this.setSize(getPreferredSize());
}
/**
* This method initializes jList
*
* @return javax.swing.JList
*/
private JList getPlayersList() {
if (playersList == null) {
playersList = new JList();
playersList
.setSelectionMode(javax.swing.ListSelectionModel.SINGLE_SELECTION);
playersList.setRequestFocusEnabled(false);
playersList.setEnabled(true);
Collections.sort(values);
playersList.setListData(values);
}
return playersList;
}
public void setup(ModelRoot modelRoot, RenderersRoot vl,
Action closeAction) {
ReadOnlyWorld w = modelRoot.getWorld();
values.clear();
this.submitButtonCallBack = closeAction;
for (int player = 0; player < w.getNumberOfPlayers(); player++) {
PlayerDetails details = new PlayerDetails();
FreerailsPrincipal principal = w.getPlayer(player).getPrincipal();
details.name = principal.getName();
NonNullElements stations = new NonNullElements(KEY.STATIONS, w,
principal);
details.stations = stations.size();
TransactionAggregator networth = new NetWorthCalculator(
w, principal);
details.networth = networth.calculateValue();
values.add(details);
}
Collections.sort(values);
playersList.setListData(values);
setSize(getPreferredSize());
}
/**
* Stores the details a player that are shown on the leaderboard.
*
* @author Luke
*/
static class PlayerDetails implements Comparable<PlayerDetails> {
String name = "player";
Money networth = new Money(0);
int stations = 0;
@Override
public String toString() {
StringBuffer sb = new StringBuffer();
sb.append(name);
sb.append(", ");
sb.append(networth.toString());
sb.append(" net worth, ");
sb.append(stations);
sb.append(" stations.");
return sb.toString();
}
public int compareTo(PlayerDetails test) {
long l = test.networth.getAmount() - networth.getAmount();
return (int) l;
}
}
} // @jve:decl-index=0:visual-constraint="67,32"

/**
*
* @author Luke
*/
public class LoadGameJPanel extends javax.swing.JPanel implements View {
private static final long serialVersionUID = -6810248272441137826L;
private ImStringList lastFiles;
/** Creates new form LoadGameJPanel */
public LoadGameJPanel() {
initComponents();
}
/** This method is called from within the constructor to
* initialize the form.
* WARNING: Do NOT modify this code. The content of this method is
* always regenerated by the Form Editor.
*/
// <editor-fold defaultstate="collapsed" desc=" Generated Code ">//GEN-BEGIN:initComponents
private void initComponents() {
java.awt.GridBagConstraints gridBagConstraints;
jScrollPane1 = new javax.swing.JScrollPane();
jList1 = new javax.swing.JList();
jLabel1 = new javax.swing.JLabel();
okButton = new javax.swing.JButton();
cancelButton = new javax.swing.JButton();
refreshButton = new javax.swing.JButton();
setLayout(new java.awt.GridBagLayout());
addComponentListener(new java.awt.event.ComponentAdapter() {
@Override
public void componentShown(java.awt.event.ComponentEvent evt) {
formComponentShown(evt);
}
});
jList1.setSelectionMode(javax.swing.ListSelectionModel.SINGLE_SELECTION);
jList1.addListSelectionListener(new javax.swing.event.ListSelectionListener() {
public void valueChanged(javax.swing.event.ListSelectionEvent evt) {
jList1ValueChanged(evt);
}
});
jScrollPane1.setViewportView(jList1);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.gridwidth = 3;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
gridBagConstraints.insets = new java.awt.Insets(7, 7, 7, 7);
add(jScrollPane1, gridBagConstraints);
jLabel1.setText("Please select a game to load.");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridwidth = 3;
gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.insets = new java.awt.Insets(7, 7, 7, 7);
add(jLabel1, gridBagConstraints);
okButton.setText("OK");
okButton.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
okButtonActionPerformed(evt);
}
});
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 2;
gridBagConstraints.insets = new java.awt.Insets(7, 7, 7, 7);
add(okButton, gridBagConstraints);
cancelButton.setText("Cancel");
cancelButton.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
cancelButtonActionPerformed(evt);
}
});
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 1;
gridBagConstraints.gridy = 2;
gridBagConstraints.insets = new java.awt.Insets(7, 7, 7, 7);
add(cancelButton, gridBagConstraints);
refreshButton.setText("Refresh");
refreshButton.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
refreshButtonActionPerformed(evt);
}
});
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 2;
gridBagConstraints.gridy = 2;
gridBagConstraints.insets = new java.awt.Insets(7, 7, 7, 7);
add(refreshButton, gridBagConstraints);
}// </editor-fold>//GEN-END:initComponents
private void refreshButtonActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_refreshButtonActionPerformed
Message2Server refreshGames = new RefreshListOfGamesMessage2Server(2);
modelRoot.sendCommand(refreshGames);
}//GEN-LAST:event_refreshButtonActionPerformed
private void formComponentShown(java.awt.event.ComponentEvent evt) {//GEN-FIRST:event_formComponentShown
}//GEN-LAST:event_formComponentShown
private void cancelButtonActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_cancelButtonActionPerformed
if(null != close)
close.actionPerformed(evt);
}//GEN-LAST:event_cancelButtonActionPerformed
private void okButtonActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_okButtonActionPerformed
String filename = (String)jList1.getSelectedValue();
Message2Server message2 = new LoadGameMessage2Server(1,
filename);
modelRoot.sendCommand(message2);
if(null != close)
close.actionPerformed(evt);
}//GEN-LAST:event_okButtonActionPerformed
private void jList1ValueChanged(javax.swing.event.ListSelectionEvent evt) {//GEN-FIRST:event_jList1ValueChanged
okButton.setEnabled(jList1.getSelectedIndex() != -1);
}//GEN-LAST:event_jList1ValueChanged
public void setup(ModelRoot m, RenderersRoot vl, Action closeAction) {
this.close = closeAction;
modelRoot = m;
updateListOfFiles();
}
private void updateListOfFiles() {
ImStringList files = (ImStringList) modelRoot.getProperty(Property.SAVED_GAMES_LIST);
Object[] saves = new Object[files.size()];
for (int i = 0; i < files.size(); i++) {
saves[i] = files.get(i);
}
jList1.setListData(saves);
okButton.setEnabled(jList1.getSelectedIndex() != -1);
lastFiles = files;
}
@Override
protected void paintComponent(Graphics g) {
ImStringList files = (ImStringList) modelRoot.getProperty(Property.SAVED_GAMES_LIST);
if(!lastFiles.equals(files)){
updateListOfFiles();
}
super.paintComponent(g);
}
ModelRoot modelRoot;
ActionListener close;
// Variables declaration - do not modify//GEN-BEGIN:variables
javax.swing.JButton cancelButton;
javax.swing.JLabel jLabel1;
javax.swing.JList jList1;
javax.swing.JScrollPane jScrollPane1;
javax.swing.JButton okButton;
javax.swing.JButton refreshButton;
// End of variables declaration//GEN-END:variables
}

/**
* This class mediates between the main map view and the overview map view. It
* does the following:<br>
* (1) Updates the rectangle on the overview map when the visible rectangle of
* the main map changes.<br>
* (2) Updates the main map visible rectangle when the user clicks on the
* overview map.<br>
* (3) Updates the main map visible rectangle when the user drags the rectangle
* on the overview map.<br>
* (4) Changes the mouse cursor to indicate that the rectangle on the overview
* map is draggable when the mouse moves into the rectangle.
*
* @author Luke Lindsay
* @version 1.0
*/
public class MainMapAndOverviewMapMediator extends MouseInputAdapter {
private JComponent overviewMapJPanel;
private JViewport viewport;
private JComponent mainMap;
private Rectangle currentVisRect;
private Point lastMouseLocation = new Point();
private boolean inside = false;
private boolean draggingAndStartedInside = false;
public MainMapAndOverviewMapMediator() {
}
public MainMapAndOverviewMapMediator(JComponent omv, JViewport v,
JComponent mm, Rectangle rect) {
setup(omv, v, mm, rect);
}
public void setup(JComponent omv, JViewport v, JComponent mm, Rectangle rect) {
currentVisRect = rect;
overviewMapJPanel = omv;
viewport = v;
mainMap = mm;
overviewMapJPanel.addMouseMotionListener(this);
overviewMapJPanel.addMouseListener(this);
viewport.addChangeListener(new javax.swing.event.ChangeListener() {
public void stateChanged(ChangeEvent e) {
updateObservedRect();
}
});
overviewMapJPanel
.addComponentListener(new java.awt.event.ComponentAdapter() {
@Override
public void componentResized(
java.awt.event.ComponentEvent evt) {
updateObservedRect();
}
@Override
public void componentShown(java.awt.event.ComponentEvent evt) {
updateObservedRect();
}
});
}
@Override
public void mouseMoved(MouseEvent evt) {
lastMouseLocation.x = evt.getX();
lastMouseLocation.y = evt.getY();
updateInside(evt);
}
@Override
public void mousePressed(MouseEvent evt) {
if (inside) {
draggingAndStartedInside = true;
}
}
@Override
public void mouseReleased(MouseEvent evt) {
draggingAndStartedInside = false;
}
@Override
public void mouseDragged(MouseEvent evt) {
if (draggingAndStartedInside) {
/*
* Rectangle r= overviewMapJPanel.mainMapVisibleRect;
* r.x+=evt.getX()-lastMouseLocation.x;
* r.y+=evt.getY()-lastMouseLocation.y;
* lastMouseLocation.x=evt.getX(); lastMouseLocation.y=evt.getY();
*
* updateInside(evt); overviewMapJPanel.repaint();
*/
int deltaX = evt.getX() - lastMouseLocation.x;
int deltaY = evt.getY() - lastMouseLocation.y;
lastMouseLocation.x = evt.getX();
lastMouseLocation.y = evt.getY();
// float overviewScale=overviewMapJPanel.getScale();
// float mainMapScale=mainMap.getScale();
int overviewScale = overviewMapJPanel.getPreferredSize().width;
int mainMapScale = mainMap.getWidth();
int scaledDeltaX = (deltaX * mainMapScale / overviewScale);
int scaledDeltaY = (deltaY * mainMapScale / overviewScale);
Rectangle r = mainMap.getVisibleRect();
r.x += scaledDeltaX;
r.y += scaledDeltaY;
mainMap.scrollRectToVisible(r);
updateInside(evt);
}
}
@Override
public void mouseClicked(MouseEvent evt) {
/*
* Rectangle r= overviewMapJPanel.mainMapVisibleRect;
* r.x=evt.getX()-r.width/2; r.y=evt.getY()-r.width/2;
*/
// float overviewScale=overviewMapJPanel.getScale();
// float mainMapScale=mainMap.getScale();
int overviewScale = overviewMapJPanel.getPreferredSize().width;
int mainMapScale = mainMap.getWidth();
int x = (evt.getX() * mainMapScale / overviewScale);
int y = (evt.getY() * mainMapScale / overviewScale);
Rectangle r = mainMap.getVisibleRect();
r.x = x - r.width / 2;
r.y = y - r.height / 2;
mainMap.scrollRectToVisible(r);
updateInside(evt);
}
private void updateInside(MouseEvent evt) {
// Rectangle r= overviewMapJPanel.mainMapVisibleRect;
boolean b = currentVisRect.contains(evt.getX(), evt.getY());
if (b != inside) {
inside = b;
if (inside) {
overviewMapJPanel.setCursor(new Cursor(Cursor.MOVE_CURSOR));
} else {
overviewMapJPanel.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
}
}
}
private void updateObservedRect() {
Rectangle r = mainMap.getVisibleRect();
// if (!r.equals(this.currentVisRect)) {
// float overviewScale=overviewMapJPanel.getScale();
// float mainMapScale=mainMap.getScale();
int overviewScale = overviewMapJPanel.getPreferredSize().width;
int mainMapScale = mainMap.getWidth();
if (0 != (overviewScale * mainMapScale)) {
// avoid division by zero.
currentVisRect.x = (r.x * overviewScale / mainMapScale);
currentVisRect.y = (r.y * overviewScale / mainMapScale);
currentVisRect.width = (r.width * overviewScale / mainMapScale);
currentVisRect.height = (r.height * overviewScale / mainMapScale);
overviewMapJPanel.repaint();
}
// }
}
}

/**
* JPanel that displays the map and provides methods to handle scrolling.
*
* @author Luke Lindsay 01 November 2001
*/
public abstract class MapViewJComponent extends JPanel implements Scrollable,
MapRenderer {
private MapRenderer mapView = new BlankMapRenderer(10);
public MapViewJComponent() {
this.setAutoscrolls(true);
}
public float getScale() {
return getMapView().getScale();
}
@Override
protected void paintComponent(java.awt.Graphics g) {
java.awt.Graphics2D g2 = (java.awt.Graphics2D) g;
java.awt.Rectangle r = this.getVisibleRect();
getMapView().paintRect(g2, r);
}
public int getScrollableUnitIncrement(java.awt.Rectangle rectangle,
int orientation, int direction) {
return (int) getMapView().getScale();
}
public boolean getScrollableTracksViewportWidth() {
return false;
}
public int getScrollableBlockIncrement(java.awt.Rectangle rectangle,
int orientation, int direction) {
if (javax.swing.SwingConstants.VERTICAL == orientation) {
int best = (int) (((rectangle.height / getMapView().getScale()) - 2) * getMapView()
.getScale());
if (best > 0) {
return best;
}
return rectangle.height;
}
float f = ((rectangle.width / getMapView().getScale()) - 2)
* getMapView().getScale();
int best = (int) (f);
if (best > 0) {
return best;
}
return rectangle.width;
}
/**
* Gets the scrollableTracksViewportHeight attribute of the
* MapViewJComponent object.
*
* @return The scrollableTracksViewportHeight value
*/
public boolean getScrollableTracksViewportHeight() {
return false;
}
/**
* Gets the preferredScrollableViewportSize attribute of the
* MapViewJComponent object.
*
* @return The preferredScrollableViewportSize value
*/
public java.awt.Dimension getPreferredScrollableViewportSize() {
return this.getPreferredSize();
}
public void centerOnTile(Point tile) {
float scale = getMapView().getScale();
Rectangle visRect = new Rectangle(this.getVisibleRect());
visRect.x = (int) (tile.x * scale - (visRect.width / 2));
visRect.y = (int) (tile.y * scale - (visRect.height / 2));
this.scrollRectToVisible(visRect);
}
public Dimension getMapSizeInPixels() {
return getMapView().getMapSizeInPixels();
}
@Override
public Dimension getPreferredSize() {
return getMapSizeInPixels();
}
void setMapView(MapRenderer mapView) {
this.mapView = mapView;
}
public MapRenderer getMapView() {
return mapView;
}
}

/**
* Displays the map, the cursor, and user messages (which are stored on the
* ModelRoot under the keys QUICK_MESSAGE and PERMANENT_MESSAGE).
*
* @author Luke Lindsay
*
*/
final public class MapViewJComponentConcrete extends MapViewJComponent
implements ModelRootListener {
private static final long serialVersionUID = 3834868087706236208L;
private static final Font USER_MESSAGE_FONT = new Font("Arial", 0, 12);
private static final Font LARGE_MESSAGE_FONT = new Font("Arial", 0, 24);
/**
* The length of the array is the number of lines. This is necessary since
* Graphics.drawString(..) doesn't know about newline characters
*/
private String[] userMessage = new String[0];
/**
* Message that will appear in the middle of the screen in
* <code>LARGE_MESSAGE_FONT</code>.
*/
private String message = null;
/** Time at which to stop displaying the current user message. */
private long displayMessageUntil = 0;
private FreerailsCursor mapCursor;
/**
* Affects scroll direction and scroll speed relative to the cursor.
* Examples:
* <p>
* 1 := grab map, move 1:1
* <p>
* -2 := invert mouse, scroll twice as fast
*/
private final int LINEAR_ACCEL = -1;
/**
* Affects the granularity of the map scrolling (the map is scrolled in
* tileSize/GRANULARITY intervals). Multiply this value with LINEAR_ACCEL to
* be independent of acceleration.
*/
private final int GRANULARITY = 2 * LINEAR_ACCEL;
/**
* A {@link Robot} to compensate mouse cursor movement.
*/
private static Robot robot;
static {
try {
robot = new Robot();
} catch (java.awt.AWTException e) {
}
}
/**
* Implements a MouseListener for FreerailsCursor-movement (left mouse
* button) and a MouseMotionListener for map-scrolling (right mouse button).
* <p>
* Possible enhancements: setCursor(blankCursor),
* g.draw(cursorimage,lastMouseLocation.x,lastMouseLocation.y,null)
*/
final private class MapViewJComponentMouseAdapter extends MouseInputAdapter {
/**
* Screen location of the mouse cursor, when the second mouse button was
* pressed.
*/
private Point screenLocation = new Point();
private Point lastMouseLocation = new Point();
/**
* A variable to sum up relative mouse movement.
*/
private Point sigmadelta = new Point();
/**
* Where to scroll - Reflects granularity, scroll direction and
* acceleration, respects bounds.
*/
private Point tiledelta = new Point();
@Override
public void mousePressed(MouseEvent evt) {
/*
* Note, moving the cursor using the mouse is now handled in
* UserInputOnMapController
*/
if (SwingUtilities.isRightMouseButton(evt)) {
MapViewJComponentConcrete.this
.setCursor(Cursor
.getPredefinedCursor((LINEAR_ACCEL > 0) ? Cursor.HAND_CURSOR
: Cursor.MOVE_CURSOR));
lastMouseLocation.x = evt.getX();
lastMouseLocation.y = evt.getY();
screenLocation.x = evt.getX();
screenLocation.y = evt.getY();
sigmadelta.x = 0;
sigmadelta.y = 0;
javax.swing.SwingUtilities.convertPointToScreen(screenLocation,
MapViewJComponentConcrete.this);
}
}
@Override
public void mouseReleased(MouseEvent evt) {
MapViewJComponentConcrete.this.setCursor(Cursor
.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
}
@Override
public void mouseDragged(MouseEvent evt) {
if (SwingUtilities.isRightMouseButton(evt)) {
sigmadelta.x += evt.getX() - lastMouseLocation.x;
sigmadelta.y += evt.getY() - lastMouseLocation.y;
int tileSize = (int) getScale();
tiledelta.x = (sigmadelta.x * GRANULARITY) / tileSize;
tiledelta.y = (sigmadelta.y * GRANULARITY) / tileSize;
tiledelta.x = ((tiledelta.x * tileSize) / GRANULARITY)
* LINEAR_ACCEL;
tiledelta.y = ((tiledelta.y * tileSize) / GRANULARITY)
* LINEAR_ACCEL;
Rectangle vr = MapViewJComponentConcrete.this.getVisibleRect();
Rectangle bounds = MapViewJComponentConcrete.this.getBounds();
int temp; // respect bounds
if ((temp = vr.x - tiledelta.x) < 0) {
sigmadelta.x += temp / LINEAR_ACCEL;
tiledelta.x += temp;
} else if ((temp = (bounds.width) - (vr.x + vr.width)
+ tiledelta.x) < 0) {
sigmadelta.x -= temp / LINEAR_ACCEL;
tiledelta.x -= temp;
}
if ((temp = vr.y - tiledelta.y) < 0) {
sigmadelta.y += temp / LINEAR_ACCEL;
tiledelta.y += temp;
} else if ((temp = (bounds.height) - (vr.y + vr.height)
+ tiledelta.y) < 0) {
sigmadelta.y -= temp / LINEAR_ACCEL;
tiledelta.y -= temp;
}
if (tiledelta.x != 0 || tiledelta.y != 0) {
vr.x -= tiledelta.x;
vr.y -= tiledelta.y;
MapViewJComponentConcrete.this.scrollRectToVisible(vr);
sigmadelta.x -= tiledelta.x / LINEAR_ACCEL;
sigmadelta.y -= tiledelta.y / LINEAR_ACCEL;
lastMouseLocation.x -= tiledelta.x;
lastMouseLocation.y -= tiledelta.y;
}
MapViewJComponentConcrete.robot.mouseMove(screenLocation.x,
screenLocation.y);
}
}
}
@Override
protected void paintComponent(java.awt.Graphics g) {
super.paintComponent(g);
if (null != mapCursor && this.isFocusOwner()) {
mapCursor.paintCursor(g, new java.awt.Dimension(30, 30));
}
if (System.currentTimeMillis() < this.displayMessageUntil) {
Rectangle visRect = this.getVisibleRect();
g.setColor(Color.WHITE);
g.setFont(USER_MESSAGE_FONT);
for (int i = 0; i < userMessage.length; i++) {
g.drawString(this.userMessage[i], 50 + visRect.x, 50
+ visRect.y + i * 20);
}
}
if (message != null) {
Rectangle visRect = this.getVisibleRect();
g.setColor(Color.lightGray);
g.setFont(LARGE_MESSAGE_FONT);
int msgWidth = g.getFontMetrics(LARGE_MESSAGE_FONT).stringWidth(
message);
int msgHeight = g.getFontMetrics(LARGE_MESSAGE_FONT).getHeight();
g.drawString(message,
(int) (visRect.x + (visRect.getWidth() - msgWidth) / 2),
(int) (visRect.y + (visRect.getHeight() - msgHeight) / 2));
}
}
public MapViewJComponentConcrete() {
super();
MapViewJComponentMouseAdapter mva = new MapViewJComponentMouseAdapter();
this.addMouseListener(mva);
this.addMouseMotionListener(mva);
}
public void setup(MapRenderer mv, ModelRootImpl mr, RenderersRoot rr)
throws IOException {
super.setMapView(mv);
this.setBorder(null);
this.mapCursor = new FreerailsCursor(mr, rr);
mr.addPropertyChangeListener(this);
}
public void setup(MapRenderer mv) {
super.setMapView(mv);
}
private void react2cursorMove(ImPoint newPoint, ImPoint oldPoint) {
float scale = getMapView().getScale();
Dimension tileSize = new Dimension((int) scale, (int) scale);
Rectangle vr = this.getVisibleRect();
Rectangle rectangleSurroundingCursor = new Rectangle(0, 0, 1, 1);
rectangleSurroundingCursor.setLocation((newPoint.x - 1)
* tileSize.width, (newPoint.y - 1) * tileSize.height);
rectangleSurroundingCursor.setSize(tileSize.width * 3,
tileSize.height * 3);
if (!(vr.contains(rectangleSurroundingCursor))) {
int x = newPoint.x * tileSize.width - vr.width / 2;
int y = newPoint.y * tileSize.height - vr.height / 2;
this.scrollRectToVisible(new Rectangle(x, y, vr.width, vr.height));
}
this.repaint((newPoint.x - 1) * tileSize.width, (newPoint.y - 1)
* tileSize.height, tileSize.width * 3, tileSize.height * 3);
this.repaint((oldPoint.x - 1) * tileSize.width, (oldPoint.y - 1)
* tileSize.height, tileSize.width * 3, tileSize.height * 3);
}
public void paintTile(Graphics g, int tileX, int tileY) {
throw new UnsupportedOperationException();
}
public void refreshTile(int x, int y) {
throw new UnsupportedOperationException();
}
public void refreshAll() {
this.getMapView().refreshAll();
}
public void paintRect(Graphics g, Rectangle visibleRect) {
throw new UnsupportedOperationException();
}
public FreerailsCursor getMapCursor() {
return mapCursor;
}
private void println(String s) {
StringTokenizer st = new StringTokenizer(s, "\n");
this.userMessage = new String[st.countTokens()];
int i = 0;
while (st.hasMoreTokens()) {
userMessage[i] = st.nextToken();
i++;
}
// Display the message for 5 seconds.
displayMessageUntil = System.currentTimeMillis() + 1000 * 5;
}
/**
* Checks what triggered the specified PropertyChangeEvent and reacts as
* follows.
* <p>
* (1) If it was ModelRoot.CURSOR_POSITION, scrolls the map if necessary.
* </p>
* <p>
* (2) If it was ModelRoot.QUICK_MESSAGE, display or hide the message as
* appropriate.
* </p>
* <p>
* (3) If it was ModelRoot.PERMANENT_MESSAGE, display or hide the message as
* appropriate.
* </p>
*/
public void propertyChange(ModelRoot.Property p, Object before, Object after) {
if (p.equals(ModelRoot.Property.CURSOR_POSITION)) {
ImPoint newPoint = (ImPoint) after;
ImPoint oldPoint = (ImPoint) before;
if (null == oldPoint) {
oldPoint = new ImPoint();
}
react2cursorMove(newPoint, oldPoint);
} else if (p.equals(ModelRoot.Property.QUICK_MESSAGE)) {
String newMessage = (String) after;
if (null != newMessage) {
println(newMessage);
} else {
// Its null, so stop displaying whatever we where displaying.
displayMessageUntil = Long.MIN_VALUE;
}
} else if (p.equals(ModelRoot.Property.PERMANENT_MESSAGE)) {
message = (String) after;
}
}
}

/**
* Provides methods that find the nearest station in a given direction, used by
* the select station popup window.
*
* @author Luke
*
*/
public class NearestStationFinder {
public static final int NOT_FOUND = Integer.MIN_VALUE;
private final ReadOnlyWorld world;
private final FreerailsPrincipal principal;
private final int MAX_DISTANCE_TO_SELECT_SQUARED = 20 * 20;
public NearestStationFinder(ReadOnlyWorld w, FreerailsPrincipal player) {
world = w;
this.principal = player;
}
public int findNearestStation(int x, int y) {
// Find nearest station.
int distanceToClosestSquared = Integer.MAX_VALUE;
NonNullElements it = new NonNullElements(KEY.STATIONS, world, principal);
int nearestStation = NOT_FOUND;
while (it.next()) {
StationModel station = (StationModel) it.getElement();
int deltaX = x - station.x;
int deltaY = y - station.y;
int distanceSquared = deltaX * deltaX + deltaY * deltaY;
if (distanceSquared < distanceToClosestSquared
&& MAX_DISTANCE_TO_SELECT_SQUARED > distanceSquared) {
distanceToClosestSquared = distanceSquared;
nearestStation = it.getIndex();
}
}
return nearestStation;
}
public int findNearestStationInDirection(int startStation, Step direction) {
int distanceToClosestSquared = Integer.MAX_VALUE;
NonNullElements it = new NonNullElements(KEY.STATIONS, world, principal);
StationModel currentStation = (StationModel) world.get(principal,
KEY.STATIONS, startStation);
int nearestStation = NOT_FOUND;
while (it.next()) {
StationModel station = (StationModel) it.getElement();
int deltaX = station.x - currentStation.x;
int deltaY = station.y - currentStation.y;
int distanceSquared = deltaX * deltaX + deltaY * deltaY;
boolean closer = distanceSquared < distanceToClosestSquared;
boolean notTheSameStation = startStation != it.getIndex();
boolean inRightDirection = isInRightDirection(direction, deltaX,
deltaY);
if (closer && inRightDirection && notTheSameStation) {
distanceToClosestSquared = distanceSquared;
nearestStation = it.getIndex();
}
}
return nearestStation;
}
/**
* Returns true if the angle between direction and the vector (deltaX,
* deltaY) is less than 45 degrees.
*/
private boolean isInRightDirection(Step direction, int deltaX, int deltaY) {
boolean isDiagonal = direction.deltaX * direction.deltaY != 0;
boolean sameXDirection = (direction.deltaX * deltaX) > 0;
boolean sameYDirection = (direction.deltaY * deltaY > 0);
boolean deltaXisLongerThanDeltaY = deltaX * deltaX < deltaY * deltaY;
if (isDiagonal) {
return sameXDirection && sameYDirection;
}
if (0 == direction.deltaX) {
return deltaXisLongerThanDeltaY && sameYDirection;
}
return !deltaXisLongerThanDeltaY && sameXDirection;
}
}

/**
* A JPanel that displays a graph of the net worth of each of the players
* against time.
*
* @author Luke
*
*/
public class NetWorthGraphJPanel extends JPanel implements View {
private static final long serialVersionUID = 3618703010813980982L;
private static final Logger logger = Logger
.getLogger(NetWorthGraphJPanel.class.getName());
private JLabel title = null;
private JLabel yAxisLabel1 = null;
private JLabel yAxisLabel3 = null;
private JLabel yAxisLabel4 = null;
private JLabel yAxisLabel2 = null;
private JLabel xAxisLabel3 = null;
private JLabel xAxisLabel2 = null;
private JLabel xAxisLabel1 = null;
private final Font FONT;
private ArrayList<CompanyDetails> companies = new ArrayList<CompanyDetails>();
private long scaleMax;
private Rectangle graphRect = new Rectangle(44, 50, 380, 245);
ActionListener submitButtonCallBack = null;
/**
* Stores the company details that are used to draw a line and title on the
* graph.
*
* @author Luke
*
*/
static class CompanyDetails {
/** The company's net worth at the end of each year. */
long[] value = new long[100];
/** The colour for the line on the graph. */
final Color color;
/** The company's name. */
final String name;
CompanyDetails(String n, Color c) {
color = c;
name = n;
for (int i = 0; i < 100; i++) {
value[i] = Integer.MIN_VALUE;
}
}
}
/**
* This method initializes
*
*/
public NetWorthGraphJPanel() {
super();
FONT = new java.awt.Font("Bookman Old Style", java.awt.Font.BOLD, 10);
initialize();
// companies.add(new CompanyDetails("Player 1", Color.BLUE));
// companies.add(new CompanyDetails("Player 2", Color.GREEN));
// companies.add(new CompanyDetails("Player 3", Color.CYAN));
// for(int i = 0; i < companies.size(); i++){
// CompanyDetails cd = (CompanyDetails)companies.get(i);
// cd.fillWithRnadomData();
// }
//
// setAppropriateScale();
}
/**
* This method initializes this
*
*/
private void initialize() {
yAxisLabel4 = new JLabel();
yAxisLabel3 = new JLabel();
yAxisLabel2 = new JLabel();
xAxisLabel1 = new JLabel();
xAxisLabel2 = new JLabel();
xAxisLabel3 = new JLabel();
title = new JLabel();
yAxisLabel1 = new JLabel();
this.setLayout(null);
this.setBackground(java.awt.Color.white);
this.setSize(444, 315);
title.setText("Net Worth");
title.setFont(new java.awt.Font("Bookman Old Style",
java.awt.Font.PLAIN, 24));
title.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
title.setLocation(0, 0);
title.setSize(444, 43);
yAxisLabel1.setText("$25");
yAxisLabel1.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
yAxisLabel3.setText("$999m");
yAxisLabel4.setText("$999M");
yAxisLabel4.setFont(new java.awt.Font("Bookman Old Style",
java.awt.Font.BOLD, 10));
yAxisLabel4.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
yAxisLabel3.setFont(new java.awt.Font("Bookman Old Style",
java.awt.Font.BOLD, 10));
yAxisLabel3.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
yAxisLabel2.setText("$50");
yAxisLabel2.setLocation(0, 167);
yAxisLabel2.setSize(40, 16);
yAxisLabel2.setHorizontalAlignment(javax.swing.SwingConstants.RIGHT);
yAxisLabel2.setFont(new java.awt.Font("Bookman Old Style",
java.awt.Font.BOLD, 10));
yAxisLabel1.setLocation(0, 227);
yAxisLabel1.setSize(40, 16);
yAxisLabel3.setLocation(0, 107);
yAxisLabel3.setSize(40, 16);
yAxisLabel4.setLocation(0, 47);
yAxisLabel4.setSize(40, 16);
xAxisLabel3.setText("2000");
xAxisLabel3.setLocation(400, 300);
xAxisLabel3.setSize(40, 17);
xAxisLabel3.setFont(new java.awt.Font("Bookman Old Style",
java.awt.Font.BOLD, 10));
xAxisLabel3.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
xAxisLabel2.setText("1950");
xAxisLabel2.setLocation(210, 300);
xAxisLabel2.setSize(40, 17);
xAxisLabel2.setFont(new java.awt.Font("Bookman Old Style",
java.awt.Font.BOLD, 10));
xAxisLabel2.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
xAxisLabel1.setText("1900");
xAxisLabel1.setLocation(20, 300);
xAxisLabel1.setSize(40, 17);
xAxisLabel1.setFont(new java.awt.Font("Bookman Old Style",
java.awt.Font.BOLD, 10));
xAxisLabel1.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
this.add(xAxisLabel3, null);
this.add(xAxisLabel2, null);
this.add(xAxisLabel1, null);
yAxisLabel1.setFont(new java.awt.Font("Bookman Old Style",
java.awt.Font.BOLD, 10));
this.add(title, null);
this.add(yAxisLabel1, null);
this.add(yAxisLabel3, null);
this.add(yAxisLabel2, null);
this.addMouseListener(new java.awt.event.MouseAdapter() {
@Override
public void mouseClicked(java.awt.event.MouseEvent e) {
if (null == submitButtonCallBack) {
System.err.println("mouseClicked");
} else {
submitButtonCallBack.actionPerformed(new ActionEvent(this,
0, null));
}
}
});
this.add(yAxisLabel4, null);
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(new BasicStroke(2f, BasicStroke.CAP_SQUARE,
BasicStroke.JOIN_BEVEL));
// Draw guide lines.
g2.setStroke(new BasicStroke(1f, BasicStroke.CAP_SQUARE,
BasicStroke.JOIN_BEVEL));
g.setColor(Color.GRAY);
for (int y = 295; y > 50; y -= 60) {
g2.drawLine(graphRect.x, y, 420, y);
}
g2.setStroke(new BasicStroke(2f, BasicStroke.CAP_SQUARE,
BasicStroke.JOIN_BEVEL));
// Draw key
for (int i = 0; i < companies.size(); i++) {
int yOffset = i * 20;
CompanyDetails company = companies.get(i);
g2.setColor(company.color);
g2.drawLine(50, 70 + yOffset, 60, 70 + yOffset);
g2.setColor(Color.BLACK);
g2.setFont(FONT);
g.drawString(company.name, 65, 72 + yOffset);
}
// Draw graphs lines
for (int i = 0; i < companies.size(); i++) {
CompanyDetails company = companies.get(i);
g2.setColor(company.color);
for (int year = 1; year < 100; year++) {
if (company.value[year] != Integer.MIN_VALUE
&& company.value[year - 1] != Integer.MIN_VALUE) {
long x1 = year * graphRect.width / 100 + graphRect.x;
long y1 = company.value[year] * graphRect.height / scaleMax;
y1 = Math.max(1, y1);
y1 = graphRect.y + graphRect.height - y1;
long x2 = (year - 1) * graphRect.width / 100 + graphRect.x;
long y2 = company.value[year - 1] * graphRect.height
/ scaleMax;
y2 = Math.max(1, y2);
y2 = graphRect.y + graphRect.height - y2;
g2.drawLine((int) x1, (int) y1, (int) x2, (int) y2);
}
}
}
// Draw axis
g2.setColor(Color.BLACK);
g2.drawLine(graphRect.x, graphRect.y, graphRect.x, graphRect.y
+ graphRect.height);
g2.drawLine(graphRect.x, graphRect.y + graphRect.height, graphRect.x
+ graphRect.width, graphRect.y + graphRect.height);
}
/**
* <p>
* Sets the value of scaleMax subject to the following constraints.
* </P>
* <p>
* (1) scaleMax >= max, where max is the max net worth value.
* </p>
* <p>
* (2) (scaleMax % 4) == 0
* </p>
* <p>
* (3) if max >= 1,000, then (scaleMax % 4,000) == 0
* </p>
* <p>
* (4) if max >= 1,000,000, then (scaleMax % 4,000,000) == 0
* </p>
* <p>
* (5) if max >= 1,000,000,000, then (scaleMax % 4,000,000,000) == 0
* </p>
*/
private void setAppropriateScale() {
long max = 0;
for (int i = 0; i < companies.size(); i++) {
CompanyDetails company = companies.get(i);
for (int year = 0; year < 100; year++) {
long value = company.value[year];
if (value > max) {
max = value;
}
}
}
long increment = 1;
while (scaleMax < max) {
scaleMax = increment;
if (scaleMax < max) {
scaleMax += increment;
int loopCount = 0;
while (scaleMax < max && loopCount < 3) {
scaleMax += increment * 2;
loopCount++;
}
}
increment = increment * 10;
}
/*
* Make sure that if the scale is in k/m/b that each of the quarter
* scales will be divisible by k/m/b.
*/
increment = 1;
for (int i = 0; i < 3; i++) {
increment = increment * 1000;
if (scaleMax >= 8 * increment && scaleMax < 12 * increment) {
scaleMax = 12 * increment;
} else if (scaleMax >= 4 * increment && scaleMax < 8 * increment) {
scaleMax = 8 * increment;
} else if (scaleMax >= 1 * increment && scaleMax < 4 * increment) {
scaleMax = 4 * increment;
}
}
if (scaleMax < 100) {
scaleMax = 100;
}
long quarterScale = scaleMax / 4;
yAxisLabel1.setText(getYScaleString(quarterScale));
yAxisLabel2.setText(getYScaleString(quarterScale * 2));
yAxisLabel3.setText(getYScaleString(quarterScale * 3));
yAxisLabel4.setText(getYScaleString(quarterScale * 4));
}
private String getYScaleString(long value) {
String abv;
if (value >= 1000000000) {
value = value / 1000000000;
abv = "b";
} else if (value >= 1000000) {
value = value / 1000000;
abv = "m";
} else if (value >= 1000) {
value = value / 1000;
abv = "k";
} else {
abv = "";
}
return "$" + String.valueOf(value) + abv;
}
public void setup(ModelRoot modelRoot, RenderersRoot vl,
Action closeAction) {
this.submitButtonCallBack = closeAction;
ReadOnlyWorld world = modelRoot.getWorld();
companies = new ArrayList<CompanyDetails>();
GameCalendar calender = (GameCalendar) world.get(ITEM.CALENDAR);
int startYear = calender.getYear(0);
int endYear = startYear + 100;
GameTime currentTime = world.currentTime();
int currentYear = calender.getYear(currentTime.getTicks());
xAxisLabel1.setText(String.valueOf(startYear));
xAxisLabel2.setText(String.valueOf(startYear + 50));
xAxisLabel3.setText(String.valueOf(endYear));
for (int i = 0; i < world.getNumberOfPlayers(); i++) {
Color c = PlayerColors.getColor(i);
Player player = world.getPlayer(i);
String name = player.getName();
logger.fine("Adding player " + name + " to net worth graph.");
CompanyDetails cd = new CompanyDetails(name, c);
GameTime[] times = new GameTime[101];
for (int year = 0; year < 101; year++) {
int ticks = calender.getTicks(startYear + year - 1);
times[year] = new GameTime(ticks);
}
TransactionAggregator aggregator = new NetWorthCalculator(world,
player.getPrincipal());
aggregator.setTimes(times);
Money[] values = aggregator.calculateValues();
int stopYear = currentYear - startYear + 1;
for (int year = 0; year < stopYear; year++) {
cd.value[year] = values[year].getAmount();
}
companies.add(cd);
}
setAppropriateScale();
}
} // @jve:decl-index=0:visual-constraint="10,10"

/**
* A JPanel that displays a newspaper headline.
*
* @author lindsal8
*
*/
public class NewsPaperJPanel extends javax.swing.JPanel implements View {
private static final long serialVersionUID = 3258410638366946868L;
private final GraphicsConfiguration defaultConfiguration = GraphicsEnvironment
.getLocalGraphicsEnvironment().getDefaultScreenDevice()
.getDefaultConfiguration();
private ActionListener callBack;
private final Image pieceOfNewspaper;
public NewsPaperJPanel() {
initComponents();
Image tempImage = (new javax.swing.ImageIcon(getClass().getResource(
"/jfreerails/data/newspaper.png"))).getImage();
pieceOfNewspaper = defaultConfiguration.createCompatibleImage(tempImage
.getWidth(null), tempImage.getHeight(null),
Transparency.BITMASK);
Graphics g = pieceOfNewspaper.getGraphics();
g.drawImage(tempImage, 0, 0, null);
this.addMouseListener(new java.awt.event.MouseAdapter() {
@Override
public void mousePressed(java.awt.event.MouseEvent evt) {
callBack.actionPerformed(new ActionEvent(this, 0, null));
}
});
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the FormEditor.
*/
private void initComponents() { // GEN-BEGIN:initComponents
headline = new javax.swing.JLabel();
jPanel1 = new javax.swing.JPanel();
anyKeyToContinueJLabel = new javax.swing.JLabel();
setLayout(null);
setPreferredSize(new java.awt.Dimension(640, 400));
setMinimumSize(new java.awt.Dimension(640, 400));
setMaximumSize(new java.awt.Dimension(640, 400));
setOpaque(false);
addKeyListener(new java.awt.event.KeyAdapter() {
@Override
public void keyPressed(java.awt.event.KeyEvent evt) {
formKeyPressed(evt);
}
});
headline.setPreferredSize(new java.awt.Dimension(620, 110));
headline.setMinimumSize(new java.awt.Dimension(620, 110));
headline.setText("NEWSPAPER HEADLINE");
headline.setForeground(java.awt.Color.black);
headline.setBackground(java.awt.Color.white);
headline.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
headline.setFont(new java.awt.Font("Lucida Bright", 1, 36));
headline.setMaximumSize(new java.awt.Dimension(620, 110));
add(headline);
headline.setBounds(10, 70, 620, 110);
jPanel1.setBorder(new javax.swing.border.BevelBorder(0));
anyKeyToContinueJLabel.setText("Click to continue");
anyKeyToContinueJLabel.setForeground(java.awt.Color.black);
anyKeyToContinueJLabel.setBackground(java.awt.Color.darkGray);
jPanel1.add(anyKeyToContinueJLabel);
add(jPanel1);
jPanel1.setBounds(230, 260, 190, 30);
}
// GEN-END:initComponents
private void formKeyPressed(java.awt.event.KeyEvent evt) { // GEN-FIRST:event_formKeyPressed
// Add your handling code here:
this.setVerifyInputWhenFocusTarget(false);
}
// GEN-LAST:event_formKeyPressed
@Override
public void paint(Graphics g) {
g.drawImage(this.pieceOfNewspaper, 0, 0, null);
this.paintChildren(g);
}
public void setHeadline(String s) {
this.headline.setText(s);
}
public void setup(ModelRoot mr, RenderersRoot vl,
Action closeAction) {
this.callBack = closeAction;
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JLabel headline;
private javax.swing.JPanel jPanel1;
private javax.swing.JLabel anyKeyToContinueJLabel;
// End of variables declaration//GEN-END:variables
}

/**
* Draws the trains on the main map.
*
* @author Luke
*/
public class OverHeadTrainView implements Painter {
private final TrainRenderer trainRenderer;
private final ReadOnlyWorld w;
private SoundManager soundManager = SoundManager.getSoundManager();
private ModelRoot mr;
public OverHeadTrainView(ReadOnlyWorld world, RenderersRoot rr, ModelRoot mr) {
this.w = world;
trainRenderer = new TrainRenderer(rr);
this.mr = mr;
}
public TrainRenderer getTrainRenderer() {
return trainRenderer;
}
public void paint(Graphics2D g) {
g.setColor(Color.BLUE);
g.setStroke(new BasicStroke(10));
Double time = (Double)mr.getProperty(Property.TIME);
for (int k = 0; k < w.getNumberOfPlayers(); k++) {
FreerailsPrincipal principal = w.getPlayer(k).getPrincipal();
int selectedTrain = -1;
if (mr.getPrincipal().getWorldIndex() == principal.getWorldIndex()) {
//These are our trains...
Object property = mr.getProperty(Property.SELECTED_TRAIN);
if (null != property) {
selectedTrain = (Integer) property;
}
}
for (int i = 0; i < w.size(principal, KEY.TRAINS); i++) {
TrainModel train = (TrainModel) w.get(principal, KEY.TRAINS, i);
// TrainPositionOnMap pos = (TrainPositionOnMap) w.get(
// principal, KEY.TRAIN_POSITIONS, i);
TrainAccessor ta = new TrainAccessor(w, principal, i);
TrainPositionOnMap pos = ta.findPosition(time);
if (pos.isCrashSite()
&& (pos.getFrameCt() <= TrainPositionOnMap.CRASH_FRAMES_COUNT)) {
trainRenderer.paintTrainCrash(g, pos);
if (pos.getFrameCt() == 1) {
try {
soundManager.playSound(
"/jfreerails/client/sounds/traincrash.wav",
1);
} catch (Exception e) {
e.printStackTrace();
}
}
} else {
TrainImages.Highlight highlight = i == selectedTrain ? TrainImages.Highlight.SELECTED: null;
trainRenderer.paintTrain(g, train, pos, highlight);
}
}
}
}
}

/**
* JPanel that displays the overview map and a rectangle showing the region of
* the map currently displayed on the main view.
*
* @author Luke
*/
public class OverviewMapJComponent extends JPanel {
private static final long serialVersionUID = 3258697585148376888L;
private MapRenderer mapView = new BlankMapRenderer(0.4F);
private final Rectangle mainMapVisRect;
public OverviewMapJComponent(Rectangle r) {
this.setPreferredSize(mapView.getMapSizeInPixels());
mainMapVisRect = r;
}
public void setup(MapRenderer mv) {
mapView = mv;
this.setPreferredSize(mapView.getMapSizeInPixels());
this.setMinimumSize(this.getPreferredSize());
this.setSize(this.getPreferredSize());
if (null != this.getParent()) {
this.getParent().validate();
}
}
@Override
protected void paintComponent(java.awt.Graphics g) {
java.awt.Graphics2D g2 = (java.awt.Graphics2D) g;
java.awt.Rectangle r = this.getVisibleRect();
mapView.paintRect(g2, r);
g2.setColor(Color.WHITE);
g2.drawRect(mainMapVisRect.x, mainMapVisRect.y, mainMapVisRect.width,
mainMapVisRect.height);
}
@Override
public Dimension getPreferredSize() {
return mapView.getMapSizeInPixels();
}
}

/**
* Stores a list of colours to use to represent different players.
*
* @author Luke
*
*/
public class PlayerColors {
private static final Color[] colors = new Color[] { Color.BLUE,
Color.GREEN, Color.CYAN, Color.MAGENTA, Color.ORANGE, Color.YELLOW };// Save
// red
// for
// when
// we
// need
// to
// grab
// the
// player's
// attention!
public static Color getColor(int playerNumber) {
return colors[playerNumber % colors.length];
}
}

/**
* The tabbed panel that sits in the lower right hand corner of the screen.
*
* @author rob
*/
public class RHSJTabPane extends JTabbedPane implements ModelRootListener {
private static final long serialVersionUID = 3906926798502965297L;
private final TerrainInfoJPanel terrainInfoPanel;
private final StationInfoJPanel stationInfoPanel;
private final TrainListJPanel trainListPanel;
private final BuildTrackJPanel buildTrackPanel;
private ReadOnlyWorld world;
private int trainListIndex;
public RHSJTabPane() {
/*
* Dont accept keyboard focus since we want to leave it with the main
* map view.
*/
setFocusable(false);
ImageIcon trainListIcon;
ImageIcon buildTrackIcon;
/* set up trainsJTabbedPane */
setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT);
terrainInfoPanel = new TerrainInfoJPanel();
trainListPanel = new TrainListJPanel(true);
buildTrackPanel = new BuildTrackJPanel();
trainListPanel.removeButtons();
URL terrainInfoIconUrl = getClass().getResource(
"/jfreerails/client/graphics/icons/terrain_info.png");
ImageIcon terrainInfoIcon = new ImageIcon(terrainInfoIconUrl);
URL buildTrackIconUrl = getClass().getResource(
"/jfreerails/client/graphics/icons/track_new.png");
buildTrackIcon = new ImageIcon(buildTrackIconUrl);
URL trainListIconUrl = getClass().getResource(
"/jfreerails/client/graphics/icons/train_list.png");
trainListIcon = new ImageIcon(trainListIconUrl);
// Note titles set to null so only the icon appears at the top of the
// top.
JScrollPane terrainInfoJScrollPane = new JScrollPane(terrainInfoPanel);
terrainInfoJScrollPane
.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
addTab(null, terrainInfoIcon, terrainInfoJScrollPane, "Terrain Info");
stationInfoPanel = new StationInfoJPanel();
stationInfoPanel.removeCloseButton();
// Don't show the station info tab until it has been rewritten to take
// up less space.
// JScrollPane stationInfoJScrollPane = new
// JScrollPane(stationInfoPanel);
// stationInfoJScrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
// addTab(null, stationInfoIcon, stationInfoJScrollPane, "Station
// Info");
// this.stationInfoIndex= this.getTabCount()-1;
trainListPanel.setTrainViewHeight(20);
addTab(null, buildTrackIcon, buildTrackPanel, "Build Track");
addTab(null, trainListIcon, trainListPanel, "Train List");
this.trainListIndex = this.getTabCount() - 1;
/* These values were picked by trial and error! */
this.setMinimumSize(new Dimension(250, 200));
}
public void setup(final ActionRoot actionRoot, RenderersRoot vl,
final ModelRootImpl modelRoot) {
world = modelRoot.getWorld();
terrainInfoPanel.setup(world, vl);
stationInfoPanel.setup(modelRoot, vl, null);
ActionListener showTrain = new ActionListener() {
public void actionPerformed(ActionEvent e) {
int id = trainListPanel.getSelectedTrainID();
actionRoot.getDialogueBoxController().showTrainOrders(id);
}
};
trainListPanel.setShowTrainDetailsActionListener(showTrain);
trainListPanel.setup(modelRoot, vl, null);
modelRoot.addPropertyChangeListener(this);
buildTrackPanel.setup(modelRoot, actionRoot, vl, null);
}
/**
* Updates the Terrain Info Panel if the specified PropertyChangeEvent was
* triggered by the cursor moving.
*/
public void propertyChange(ModelRoot.Property prop, Object before,
Object after) {
if (prop.equals(ModelRoot.Property.CURSOR_POSITION)) {
ImPoint p = (ImPoint) after;
terrainInfoPanel.setTerrainType(((FreerailsTile) world.getTile(p.x,
p.y)).getTerrainTypeID());
}
}
public void setTrainTabEnabled(boolean enabled) {
this.setEnabledAt(this.trainListIndex, enabled);
}
public void setStationTabEnabled(boolean enabled) {
// this.setEnabledAt(this.stationInfoIndex, enabled);
}
}

/**
*
* @author Luke
*/
public class SaveGameJPanel extends javax.swing.JPanel implements View{
private static final long serialVersionUID = 4031907071040752589L;
/** Creates new form SaveGameJPanel */
public SaveGameJPanel() {
initComponents();
}
/** This method is called from within the constructor to
* initialize the form.
* WARNING: Do NOT modify this code. The content of this method is
* always regenerated by the Form Editor.
*/
// <editor-fold defaultstate="collapsed" desc=" Generated Code ">//GEN-BEGIN:initComponents
private void initComponents() {
java.awt.GridBagConstraints gridBagConstraints;
jLabel1 = new javax.swing.JLabel();
fileNameTextField = new javax.swing.JTextField();
oKButton = new javax.swing.JButton();
cancelButton = new javax.swing.JButton();
setLayout(new java.awt.GridBagLayout());
jLabel1.setText("Please enter a name for the save game.");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridwidth = 2;
gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
gridBagConstraints.insets = new java.awt.Insets(7, 7, 7, 7);
add(jLabel1, gridBagConstraints);
fileNameTextField.setText("savegame");
fileNameTextField.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
fileNameTextFieldActionPerformed(evt);
}
});
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.gridwidth = 2;
gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
gridBagConstraints.insets = new java.awt.Insets(7, 7, 7, 7);
add(fileNameTextField, gridBagConstraints);
oKButton.setText("OK");
oKButton.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
oKButtonActionPerformed(evt);
}
});
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 2;
gridBagConstraints.insets = new java.awt.Insets(7, 7, 7, 7);
add(oKButton, gridBagConstraints);
cancelButton.setText("Cancel");
cancelButton.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
cancelButtonActionPerformed(evt);
}
});
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 1;
gridBagConstraints.gridy = 2;
gridBagConstraints.insets = new java.awt.Insets(7, 7, 7, 7);
add(cancelButton, gridBagConstraints);
}
// </editor-fold>//GEN-END:initComponents
private void oKButtonActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_oKButtonActionPerformed
String filename = fileNameTextField.getText();
// Save the current game using the string
modelRoot.setProperty(Property.QUICK_MESSAGE, "Saved game "
+ filename);
Message2Server message2 = new SaveGameMessage2Server(1,
filename + ".sav");
modelRoot.sendCommand(message2);
close.actionPerformed(evt);
}//GEN-LAST:event_oKButtonActionPerformed
private void cancelButtonActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_cancelButtonActionPerformed
close.actionPerformed(evt);
}//GEN-LAST:event_cancelButtonActionPerformed
private void fileNameTextFieldActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_fileNameTextFieldActionPerformed
// TODO add your handling code here:
System.out.println("fileNameTextFieldActionPerformed"+evt.toString());
}//GEN-LAST:event_fileNameTextFieldActionPerformed
public void setup(ModelRoot m, RenderersRoot vl,
Action closeAction) {
this.close = closeAction;
this.modelRoot = m;
}
ModelRoot modelRoot;
ActionListener close;
// Variables declaration - do not modify//GEN-BEGIN:variables
javax.swing.JButton cancelButton;
javax.swing.JTextField fileNameTextField;
javax.swing.JLabel jLabel1;
javax.swing.JButton oKButton;
// End of variables declaration//GEN-END:variables
}

/**
* This JPanel lets the user select an engine from a list.
*
* @author lindsal8
*
*/
public class SelectEngineJPanel extends javax.swing.JPanel implements View {
private static final long serialVersionUID = 4122537730158179638L;
public SelectEngineJPanel() {
initComponents();
jList1ValueChanged(null); // Disable the ok button if no engine type
// is selected.
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the FormEditor.
*/
private void initComponents() {// GEN-BEGIN:initComponents
java.awt.GridBagConstraints gridBagConstraints;
okjButton = new javax.swing.JButton();
canceljButton = new javax.swing.JButton();
jScrollPane1 = new javax.swing.JScrollPane();
jList1 = new javax.swing.JList();
setLayout(new java.awt.GridBagLayout());
setPreferredSize(new java.awt.Dimension(400, 350));
okjButton.setText("OK");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 1;
gridBagConstraints.gridy = 1;
gridBagConstraints.insets = new java.awt.Insets(10, 10, 9, 10);
add(okjButton, gridBagConstraints);
canceljButton.setText("Cancel");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 2;
gridBagConstraints.gridy = 1;
gridBagConstraints.insets = new java.awt.Insets(10, 10, 10, 10);
add(canceljButton, gridBagConstraints);
jList1
.setSelectionMode(javax.swing.ListSelectionModel.SINGLE_SELECTION);
jList1
.addListSelectionListener(new javax.swing.event.ListSelectionListener() {
public void valueChanged(
javax.swing.event.ListSelectionEvent evt) {
jList1ValueChanged(evt);
}
});
jScrollPane1.setViewportView(jList1);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 1;
gridBagConstraints.gridy = 0;
gridBagConstraints.gridwidth = 3;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
add(jScrollPane1, gridBagConstraints);
}// GEN-END:initComponents
private void jList1ValueChanged(javax.swing.event.ListSelectionEvent evt) { // GEN-FIRST:event_jList1ValueChanged
// We need to disable the OK button if no engine type is selected.
if (-1 == jList1.getSelectedIndex()) {
okjButton.setEnabled(false);
} else {
okjButton.setEnabled(true);
}
} // GEN-LAST:event_jList1ValueChanged
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JButton canceljButton;
private javax.swing.JList jList1;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JButton okjButton;
// End of variables declaration//GEN-END:variables
final private class TrainCellRenderer implements ListCellRenderer {
final JLabel label;
final RenderersRoot rr;
public TrainCellRenderer(RenderersRoot vl) {
rr = vl;
label = new JLabel();
}
public Component getListCellRendererComponent(JList list, Object value,
/* value to display */
int index, /* cell index */
boolean isSelected, /* is the cell selected */
boolean cellHasFocus) /* the list and the cell have the focus */{
EngineType engine = (EngineType) value;
label.setFont(new java.awt.Font("Dialog", 0, 12));
String text = "<html><body>" + (isSelected ? "<strong>" : "")
+ engine.getEngineTypeName() + "<br>"
+ engine.getMaxSpeed() + " m.p.h. "
+ engine.getPowerAtDrawbar() + " hp $"
+ engine.getPrice().toString()
+ (isSelected ? "</strong>" : "") + "</body></html>";
label.setText(text);
Image image = rr.getEngineImages(index).getSideOnImage();
int height = image.getHeight(null);
int width = image.getWidth(null);
int scale = height / 50;
ImageIcon icon = new ImageIcon(image.getScaledInstance(width
/ scale, height / scale, Image.SCALE_FAST));
label.setIcon(icon);
return label;
}
}
public void setup(ModelRoot mr, RenderersRoot vl,
Action closeAction) {
jList1.setModel(new World2ListModelAdapter(mr.getWorld(),
SKEY.ENGINE_TYPES));
jList1.setCellRenderer(new TrainCellRenderer(vl));
okjButton.addActionListener(closeAction);
}
/**
* Removes any existing ActionListener listeners from the cancel button,
* then adds the specified one.
*/
void setCancelButtonActionListener(ActionListener l) {
ActionListener[] oldListeners = canceljButton.getActionListeners();
for (int i = 0; i < oldListeners.length; i++) {
canceljButton.removeActionListener(oldListeners[i]);
}
this.canceljButton.addActionListener(l);
}
/**
* Returns the number of the currently selected engine type.
*
*/
public int getEngineType() {
return jList1.getSelectedIndex();
}
}

/**
* This JPanel lets the user select a station from a map and add it to a train
* schedule.
*
* @author Luke
*/
public class SelectStationJPanel extends javax.swing.JPanel implements View {
private static final long serialVersionUID = 3258411750662877488L;
private ReadOnlyWorld world;
private ActionListener submitButtonCallBack;
private int selectedStationID = 0;
private int selectedOrderNumber = 1;
private MutableSchedule schedule;
private Rectangle mapRect = new Rectangle();
private Rectangle visibleMapTiles = new Rectangle();
private double scale = 1;
private boolean needsUpdating = true;
private FreerailsPrincipal principal;
public SelectStationJPanel() {
initComponents();
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
private void initComponents() {// GEN-BEGIN:initComponents
java.awt.GridBagConstraints gridBagConstraints;
cargoWaitingAndDemandedJPanel1 = new jfreerails.client.view.CargoWaitingAndDemandedJPanel();
jLabel1 = new javax.swing.JLabel();
setLayout(new java.awt.GridBagLayout());
setPreferredSize(new java.awt.Dimension(500, 350));
addComponentListener(new java.awt.event.ComponentAdapter() {
@Override
public void componentResized(java.awt.event.ComponentEvent evt) {
formComponentResized(evt);
}
@Override
public void componentShown(java.awt.event.ComponentEvent evt) {
formComponentShown(evt);
}
});
addKeyListener(new java.awt.event.KeyAdapter() {
@Override
public void keyPressed(java.awt.event.KeyEvent evt) {
formKeyPressed(evt);
}
});
addMouseListener(new java.awt.event.MouseAdapter() {
@Override
public void mouseClicked(java.awt.event.MouseEvent evt) {
formMouseClicked(evt);
}
});
addMouseMotionListener(new java.awt.event.MouseMotionAdapter() {
@Override
public void mouseMoved(java.awt.event.MouseEvent evt) {
formMouseMoved(evt);
}
});
cargoWaitingAndDemandedJPanel1
.setBorder(new javax.swing.border.LineBorder(
new java.awt.Color(0, 0, 0)));
cargoWaitingAndDemandedJPanel1.setPreferredSize(new java.awt.Dimension(
165, 300));
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 1;
gridBagConstraints.gridy = 1;
gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHEAST;
gridBagConstraints.weighty = 1.0;
gridBagConstraints.insets = new java.awt.Insets(7, 7, 7, 7);
add(cargoWaitingAndDemandedJPanel1, gridBagConstraints);
jLabel1.setText("Train #1 Stop 1");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 0;
gridBagConstraints.gridwidth = 2;
gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTH;
gridBagConstraints.weightx = 1.0;
add(jLabel1, gridBagConstraints);
}// GEN-END:initComponents
private void formComponentShown(java.awt.event.ComponentEvent evt) {// GEN-FIRST:event_formComponentShown
setZoom();
}// GEN-LAST:event_formComponentShown
private void formMouseClicked(java.awt.event.MouseEvent evt) {// GEN-FIRST:event_formMouseClicked
formMouseMoved(evt);
needsUpdating = true;
this.submitButtonCallBack.actionPerformed(null);
}// GEN-LAST:event_formMouseClicked
private void formKeyPressed(java.awt.event.KeyEvent evt) {// GEN-FIRST:event_formKeyPressed
try {
Step v = KeyCode2OneTileMoveVector.getInstanceMappedToKey(evt
.getKeyCode());
// now find nearest station in direction of the vector.
NearestStationFinder stationFinder = new NearestStationFinder(
this.world, this.principal);
int station = stationFinder.findNearestStationInDirection(
this.selectedStationID, v);
if (selectedStationID != station
&& station != NearestStationFinder.NOT_FOUND) {
selectedStationID = station;
cargoWaitingAndDemandedJPanel1.display(selectedStationID);
this.validate();
this.repaint();
}
} catch (NoSuchElementException e) {
if (evt.getKeyCode() == KeyEvent.VK_ENTER) {
needsUpdating = true;
submitButtonCallBack.actionPerformed(null);
}
// The key pressed isn't mapped to a OneTileMoveVector so do
// nothing.
}
}// GEN-LAST:event_formKeyPressed
private void formComponentResized(java.awt.event.ComponentEvent evt) {// GEN-FIRST:event_formComponentResized
setZoom();
}// GEN-LAST:event_formComponentResized
private void formMouseMoved(java.awt.event.MouseEvent evt) {// GEN-FIRST:event_formMouseMoved
// Add your handling code here:
double x = evt.getX();
x = x / scale + visibleMapTiles.x;
double y = evt.getY();
y = y / scale + visibleMapTiles.y;
NearestStationFinder stationFinder = new NearestStationFinder(
this.world, this.principal);
int station = stationFinder.findNearestStation((int) x, (int) y);
if (selectedStationID != station
&& station != NearestStationFinder.NOT_FOUND) {
selectedStationID = station;
cargoWaitingAndDemandedJPanel1.display(selectedStationID);
this.validate();
this.repaint();
}
}// GEN-LAST:event_formMouseMoved
public void display(MutableSchedule newSchedule, int orderNumber) {
this.schedule = newSchedule;
this.selectedOrderNumber = orderNumber;
TrainOrdersModel order = newSchedule.getOrder(selectedOrderNumber);
this.selectedStationID = order.getStationID();
// Set the text on the title JLabel.
this.jLabel1.setText("Stop " + String.valueOf(selectedOrderNumber + 1));
// Set the station info panel to show the current selected station.
cargoWaitingAndDemandedJPanel1.display(selectedStationID);
}
/**
* Sets the zoom based on the size of the component and the positions of the
* stations.
*/
private void setZoom() {
mapRect = this.getBounds();
Rectangle r = cargoWaitingAndDemandedJPanel1.getBounds();
mapRect.width -= r.width;
int topLeftX = Integer.MAX_VALUE;
int topLeftY = Integer.MAX_VALUE;
int bottomRightX = Integer.MIN_VALUE;
int bottomRightY = Integer.MIN_VALUE;
NonNullElements it = new NonNullElements(KEY.STATIONS, world,
this.principal);
while (it.next()) {
StationModel station = (StationModel) it.getElement();
if (station.x < topLeftX)
topLeftX = station.x;
if (station.y < topLeftY)
topLeftY = station.y;
if (station.x > bottomRightX)
bottomRightX = station.x;
if (station.y > bottomRightY)
bottomRightY = station.y;
}
// Add some padding.
topLeftX -= 10;
topLeftY -= 10;
bottomRightX += 10;
bottomRightY += 10;
int width = bottomRightX - topLeftX;
int height = bottomRightY - topLeftY;
visibleMapTiles = new Rectangle(topLeftX, topLeftY, width, height);
boolean heightConstraintBinds = (visibleMapTiles.getHeight() / visibleMapTiles
.getWidth()) > (mapRect.getHeight() / mapRect.getWidth());
if (heightConstraintBinds) {
scale = mapRect.getHeight() / visibleMapTiles.getHeight();
} else {
scale = mapRect.getWidth() / visibleMapTiles.getWidth();
}
needsUpdating = false;
}
@Override
protected void paintComponent(Graphics g) {
if (needsUpdating) {
this.setZoom();
}
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;
NonNullElements it = new NonNullElements(KEY.STATIONS, world,
this.principal);
// Draw track
g2.setColor(Color.BLACK);
for (int x = Math.max(0, visibleMapTiles.x); x < Math.min(
visibleMapTiles.width + visibleMapTiles.x, world.getMapWidth()); x++) {
for (int y = Math.max(0, visibleMapTiles.y); y < Math.min(
visibleMapTiles.height + visibleMapTiles.y, world
.getMapHeight()); y++) {
FreerailsTile tt = (FreerailsTile) world.getTile(x, y);
if (!tt.getTrackPiece().equals(NullTrackPiece.getInstance())) {
double xDouble = x - visibleMapTiles.x;
xDouble = xDouble * scale;
double yDouble = y - visibleMapTiles.y;
yDouble = yDouble * scale;
g.drawRect((int) xDouble, (int) yDouble, 1, 1);
}
}
}
// Draw stations
while (it.next()) {
/*
* (1) The selected station is drawn green. (2) Non-selected
* stations which are on the schedule are drawn blue. (3) Other
* stations are drawn white. (4) If, for instance, station X is the
* first stop on the schedule, "1" is drawn above the station. (5)
* If, for instance, station X is the first and third stop on the
* schedule, "1, 3" is drawn above the station. (6) The stop numbers
* drawn above the stations are drawn using the same colour as used
* to draw the station.
*/
StationModel station = (StationModel) it.getElement();
double x = station.x - visibleMapTiles.x;
x = x * scale;
double y = station.y - visibleMapTiles.y;
y = y * scale;
int xInt = (int) x;
int yInt = (int) y;
String stopNumbersString = "";
boolean stationIsOnSchedule = false;
for (int orderNumber = 0; orderNumber < schedule.getNumOrders(); orderNumber++) {
int stationID = orderNumber == this.selectedOrderNumber ? this.selectedStationID
: schedule.getOrder(orderNumber).getStationID();
if (it.getIndex() == stationID) {
if (stationIsOnSchedule) {
stopNumbersString = stopNumbersString + ", "
+ String.valueOf(orderNumber + 1);
} else {
stopNumbersString = String.valueOf(orderNumber + 1);
}
stationIsOnSchedule = true;
}
}
if (stationIsOnSchedule) {
if (it.getIndex() == selectedStationID) {
g2.setColor(Color.GREEN);
} else {
g2.setColor(Color.BLUE);
}
g2.drawString(stopNumbersString, xInt, yInt - 4);
} else {
g2.setColor(Color.WHITE);
}
g2.fillRect(xInt, yInt, 10, 10);
}
}
public void setup(ModelRoot mr, RenderersRoot vl,
Action closeAction) {
cargoWaitingAndDemandedJPanel1.setup(mr, vl, null);
this.world = mr.getWorld();
this.submitButtonCallBack = closeAction;
principal = mr.getPrincipal();
}
public MutableSchedule generateNewSchedule() {
TrainOrdersModel oldOrders, newOrders;
oldOrders = schedule.getOrder(selectedOrderNumber);
newOrders = new TrainOrdersModel(selectedStationID, oldOrders
.getConsist(), oldOrders.getWaitUntilFull(), oldOrders
.isAutoConsist());
schedule.setOrder(selectedOrderNumber, newOrders);
return schedule;
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private jfreerails.client.view.CargoWaitingAndDemandedJPanel cargoWaitingAndDemandedJPanel1;
private javax.swing.JLabel jLabel1;
// End of variables declaration//GEN-END:variables
}

/**
* This JPanel lets the user add wagons to a train.
*
* @author lindsal8
*
*/
public class SelectWagonsJPanel extends javax.swing.JPanel implements View {
private static final long serialVersionUID = 3905239009449095220L;
private final GraphicsConfiguration defaultConfiguration = GraphicsEnvironment
.getLocalGraphicsEnvironment().getDefaultScreenDevice()
.getDefaultConfiguration();
private final Image stationView;
private final ArrayList<Integer> wagons = new ArrayList<Integer>();
private int engineType = 0;
private RenderersRoot rr;
public SelectWagonsJPanel() {
initComponents();
updateMaxWagonsText();
URL url = SelectWagonsJPanel.class
.getResource("/jfreerails/data/station.gif");
Image tempImage = (new javax.swing.ImageIcon(url)).getImage();
stationView = defaultConfiguration.createCompatibleImage(tempImage
.getWidth(null), tempImage.getHeight(null),
Transparency.BITMASK);
Graphics g = stationView.getGraphics();
g.drawImage(tempImage, 0, 0, null);
}
public void resetSelectedWagons() {
this.wagons.clear();
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the FormEditor.
*/
private void initComponents() {// GEN-BEGIN:initComponents
java.awt.GridBagConstraints gridBagConstraints;
jPanel1 = new javax.swing.JPanel();
jScrollPane1 = new javax.swing.JScrollPane();
wagonTypesJList = new javax.swing.JList();
okjButton = new javax.swing.JButton();
clearjButton = new javax.swing.JButton();
jLabel1 = new javax.swing.JLabel();
setLayout(new java.awt.GridBagLayout());
setBackground(new java.awt.Color(0, 255, 51));
setMinimumSize(new java.awt.Dimension(640, 400));
setPreferredSize(new java.awt.Dimension(620, 380));
jPanel1.setLayout(new java.awt.GridBagLayout());
jPanel1.setMinimumSize(new java.awt.Dimension(170, 300));
jPanel1.setPreferredSize(new java.awt.Dimension(170, 300));
wagonTypesJList.addKeyListener(new java.awt.event.KeyAdapter() {
@Override
public void keyTyped(java.awt.event.KeyEvent evt) {
wagonTypesJListKeyTyped(evt);
}
});
wagonTypesJList.addMouseListener(new java.awt.event.MouseAdapter() {
@Override
public void mouseClicked(java.awt.event.MouseEvent evt) {
wagonTypesJListMouseClicked(evt);
}
});
jScrollPane1.setViewportView(wagonTypesJList);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 0;
gridBagConstraints.gridwidth = 2;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
jPanel1.add(jScrollPane1, gridBagConstraints);
okjButton.setText("OK");
okjButton.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
okButtonAction(evt);
}
});
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 1;
gridBagConstraints.gridy = 2;
gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
jPanel1.add(okjButton, gridBagConstraints);
clearjButton.setText("Clear");
clearjButton.setActionCommand("clear");
clearjButton.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton1ActionPerformed(evt);
}
});
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 2;
gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
jPanel1.add(clearjButton, gridBagConstraints);
jLabel1.setFont(new java.awt.Font("Dialog", 0, 10));
jLabel1.setText("The maximum train length is 6 wagons");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.gridwidth = 2;
gridBagConstraints.insets = new java.awt.Insets(8, 8, 8, 8);
jPanel1.add(jLabel1, gridBagConstraints);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 0;
gridBagConstraints.insets = new java.awt.Insets(20, 400, 70, 10);
gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHEAST;
add(jPanel1, gridBagConstraints);
}// GEN-END:initComponents
private void okButtonAction(java.awt.event.ActionEvent evt) { // GEN-FIRST:event_okButtonAction
// Add your handling code here:
} // GEN-LAST:event_okButtonAction
private void wagonTypesJListMouseClicked(java.awt.event.MouseEvent evt) { // GEN-FIRST:event_wagonTypesJListMouseClicked
// Add your handling code here:
addwagon();
} // GEN-LAST:event_wagonTypesJListMouseClicked
private void wagonTypesJListKeyTyped(java.awt.event.KeyEvent evt) { // GEN-FIRST:event_wagonTypesJListKeyTyped
// Add your handling code here:
if (KeyEvent.VK_ENTER == evt.getKeyCode()) {
addwagon();
} else {
}
} // GEN-LAST:event_wagonTypesJListKeyTyped
// Adds the wagon selected in the list to the train consist.
private void addwagon() {
if (wagons.size() < TrainModel.MAX_NUMBER_OF_WAGONS) {
int type = wagonTypesJList.getSelectedIndex();
wagons.add(new Integer(type));
updateMaxWagonsText();
this.repaint();
}
}
private void updateMaxWagonsText() {
if (wagons.size() >= TrainModel.MAX_NUMBER_OF_WAGONS) {
jLabel1.setText("Max train length is "
+ TrainModel.MAX_NUMBER_OF_WAGONS + " wagons");
} else {
jLabel1.setText("");
}
}
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) { // GEN-FIRST:event_jButton1ActionPerformed
// Add your handling code here:
wagons.clear();
jLabel1.setText("");
this.repaint();
} // GEN-LAST:event_jButton1ActionPerformed
@Override
public void paint(Graphics g) {
// paint the background
g.drawImage(this.stationView, 0, 0, null);
int x = this.getWidth();
int y = 330;
final int SCALED_IMAGE_HEIGHT = 50;
// paint the wagons
for (int i = this.wagons.size() - 1; i >= 0; i--) { // Count down so we
// paint the wagon
// at the end of the
// train first.
Integer type = wagons.get(i);
Image image = rr.getWagonImages(type.intValue()).getSideOnImage();
int scaledWidth = image.getWidth(null) * SCALED_IMAGE_HEIGHT
/ image.getHeight(null);
x -= scaledWidth;
g.drawImage(image, x, y, scaledWidth, SCALED_IMAGE_HEIGHT, null);
}
// paint the engine
if (-1 != this.engineType) { // If an engine is selected.
Image image = rr.getEngineImages(engineType).getSideOnImage();
int scaledWidth = (image.getWidth(null) * SCALED_IMAGE_HEIGHT)
/ image.getHeight(null);
x -= scaledWidth;
g.drawImage(image, x, y, scaledWidth, SCALED_IMAGE_HEIGHT, null);
}
this.paintChildren(g);
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JButton clearjButton;
private javax.swing.JLabel jLabel1;
private javax.swing.JPanel jPanel1;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JButton okjButton;
private javax.swing.JList wagonTypesJList;
// End of variables declaration//GEN-END:variables
final private class WagonCellRenderer implements ListCellRenderer {
private final Component[] labels;
final RenderersRoot rr;
public WagonCellRenderer(World2ListModelAdapter w2lma, RenderersRoot s) {
rr = s;
labels = new Component[w2lma.getSize()];
for (int i = 0; i < w2lma.getSize(); i++) {
JLabel label = new JLabel();
label.setFont(new java.awt.Font("Dialog", 0, 12));
Image image = rr.getWagonImages(i).getSideOnImage();
int height = image.getHeight(null);
int width = image.getWidth(null);
int scale = height / 10;
ImageIcon icon = new ImageIcon(image.getScaledInstance(width
/ scale, height / scale, Image.SCALE_FAST));
label.setIcon(icon);
labels[i] = label;
}
}
public Component getListCellRendererComponent(JList list, Object value, /*
* value
* to
* display
*/
int index, /* cell index */
boolean isSelected, /* is the cell selected */
boolean cellHasFocus) /* the list and the cell have the focus */{
if (index >= 0 && index < labels.length) {
CargoType cargoType = (CargoType) value;
String text = "<html><body>"
+ (isSelected ? "<strong>" : "")
+ cargoType.getDisplayName()
+ (isSelected ? "</strong>"
: "&nbsp;&nbsp;&nbsp;&nbsp;"/*
* padding to stop
* word wrap due to
* greater width of
* strong font
*/) + "</body></html>";
((JLabel) labels[index]).setText(text);
return labels[index];
}
return null;
}
}
public void setup(ModelRoot mr, RenderersRoot vl,
Action closeAction) {
World2ListModelAdapter w2lma = new World2ListModelAdapter(
mr.getWorld(), SKEY.CARGO_TYPES);
this.wagonTypesJList.setModel(w2lma);
this.rr = vl;
WagonCellRenderer wagonCellRenderer = new WagonCellRenderer(w2lma,
rr);
this.wagonTypesJList.setCellRenderer(wagonCellRenderer);
this.okjButton.addActionListener(closeAction);
}
public int[] getWagons() {
int[] wagonsArray = new int[wagons.size()];
for (int i = 0; i < wagons.size(); i++) {
Integer type = wagons.get(i);
wagonsArray[i] = type.intValue();
}
return wagonsArray;
}
public void setEngineType(int engineType) {
this.engineType = engineType;
}
}

/**
* Exposes the ServerControlInterface to client UI implementations.
*
* @author rob
* @author Luke
* @author MystiqueAgent
*/
public class ServerControlModel implements ModelRootListener{
private class LoadGameAction extends AbstractAction {
private static final long serialVersionUID = 3616451215278682931L;
public LoadGameAction() {
putValue(NAME, "Load Game");
putValue(MNEMONIC_KEY, new Integer(76));
}
public void actionPerformed(ActionEvent e) {
dbc.showSelectSavedGame2Load();
/*
ImStringList files = (ImStringList)modelRoot.getProperty(Property.SAVED_GAMES_LIST);
Object[] saves = new Object[files.size()];
for (int i = 0; i < files.size(); i++) {
saves[i] = files.get(i);
}
// Display a JOptionPane that lists the existing saved games
try {
Object showInputDialog = JOptionPane.showInputDialog(null,
"Saved Games:", "Select game to load",
JOptionPane.INFORMATION_MESSAGE, null, saves, saves[0]);
String filename = showInputDialog.toString();
// Load the game chosen
Message2Server message2 = new LoadGameMessage2Server(1,
filename);
modelRoot.sendCommand(message2);
} catch (Exception exept) {
// <Hack>
// When no saved game is selected, or one that doesnt exist,
// nothing changes
// </.Hack>
}
*/
}
}
private class NewGameAction extends AbstractAction {
private static final long serialVersionUID = 3690758388631745337L;
public NewGameAction(String s) {
if (s == null) {
putValue(NAME, "New Game...");
} else {
putValue(NAME, s);
putValue(ACTION_COMMAND_KEY, s);
}
}
public void actionPerformed(ActionEvent e) {
String mapName = e.getActionCommand();
if (mapName != null) {
Message2Server message2 = new NewGameMessage2Server(1, mapName);
modelRoot.sendCommand(message2);
}
}
}
private class SaveGameAction extends AbstractAction {
private static final long serialVersionUID = 3905808578064562480L;
public SaveGameAction() {
putValue(NAME, "Save Game");
putValue(MNEMONIC_KEY, new Integer(83));
}
public void actionPerformed(ActionEvent e) {
dbc.showSaveGame();
/*
try {
// @SonnyZ
// Show a JOptionPane that takes in a string from a text box
String filename = JOptionPane.showInputDialog(null,
"Saved Game Name:", "Save Game",
JOptionPane.QUESTION_MESSAGE, null, null,
modelRoot.getPrincipal().getName()).toString();
// Save the current game using the string
modelRoot.setProperty(Property.QUICK_MESSAGE, "Saved game "
+ filename);
Message2Server message2 = new SaveGameMessage2Server(1,
filename + ".sav");
modelRoot.sendCommand(message2);
loadGameAction.setEnabled(true);
} catch (Exception except) {
}
*/
}
}
private class SetTargetTicksPerSecondAction extends AbstractAction {
private static final long serialVersionUID = 3256437014978048052L;
final int speed;
/**
* Same as the constructor above but it enables also to associate a
* <code>keyEvent</code> with the action.
*
* @param name
* action name
* @param speed
* speed
* @param keyEvent
* associated key event. Use values from
* <code>KeyEvent</class>.
*
* by MystiqueAgent
*/
public SetTargetTicksPerSecondAction(String name, int speed,
int keyEvent) {
putValue(NAME, name);
this.speed = speed;
putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(keyEvent, 0));
}
public void actionPerformed(ActionEvent e) {
int speed2set = speed;
if (speed == 0) { // pausing/unpausing
speed2set = -1 * getTargetTicksPerSecond();
}
modelRoot.doMove(ChangeGameSpeedMove.getMove(modelRoot.getWorld(),
new GameSpeed(speed2set)));
}
}
private final Action loadGameAction = new LoadGameAction();
private ModelRootImpl modelRoot;
private final Action newGameAction = new NewGameAction(null);
private final Action saveGameAction = new SaveGameAction();
private ActionAdapter selectMapActions;
private final SetTargetTicksPerSecondAction[] speedActions = new SetTargetTicksPerSecondAction[] {
new SetTargetTicksPerSecondAction("Pause", 0, KeyEvent.VK_P),
new SetTargetTicksPerSecondAction("Slow", 10, KeyEvent.VK_1),
new SetTargetTicksPerSecondAction("Moderate", 30, KeyEvent.VK_2),
new SetTargetTicksPerSecondAction("Fast", 70, KeyEvent.VK_3),
};
private final ActionAdapter targetTicksPerSecondActions = new ActionAdapter(
speedActions, 0);
private DialogueBoxController dbc;
public ServerControlModel(ModelRootImpl mr) {
this.modelRoot = mr;
mr.addPropertyChangeListener(this);
setServerControlInterface();
}
/**
* Returns human readable string description of <code>tickPerSecond</code>
* number. Looks for <code>tickPerSecond</code> in
* <code>targetTicksPerSecondActions</code>. If appropriate action is not
* found returns first greater value or the greatest value.
*
* @param tickPerSecond
* int
* @return String human readable description
*/
public String getGameSpeedDesc(int tickPerSecond) {
SetTargetTicksPerSecondAction action = null;
for (int i = 0; i < speedActions.length; i++) {
action = speedActions[i];
if (action.speed >= tickPerSecond)
break;
}
return (String) action.getValue(Action.NAME);
}
/**
* @return an action to load a game.
*/
public Action getLoadGameAction() {
return loadGameAction;
}
/**
* @return an ActionAdapter representing a list of actions representing
* valid map names.
*/
public ActionAdapter getMapNames() {
return selectMapActions;
}
/**
* When calling this action, set the action command string to the desired
* map name, or call the appropriate selectMapAction.
*
* @return an action to start a new game
*/
public Action getNewGameAction() {
return newGameAction;
}
/**
* @return an action to save a game TODO The action produces a file selector
* dialog to save the game
*/
public Action getSaveGameAction() {
return saveGameAction;
}
/**
* @return an action adapter to set the target ticks per second
*/
public ActionAdapter getSetTargetTickPerSecondActions() {
return targetTicksPerSecondActions;
}
public int getTargetTicksPerSecond() {
ReadOnlyWorld world = modelRoot.getWorld();
return ((GameSpeed) world.get(ITEM.GAME_SPEED)).getSpeed();
}
public void propertyChange(Property p, Object oldValue, Object newValue) {
// switch (p) {
// case SAVED_GAMES_LIST:
// updateLoadGameAction();
// break;
//
// default:
// break;
// }
}
public void setup(ModelRootImpl modelRoot, DialogueBoxController dbc) {
this.modelRoot = modelRoot;
this.dbc = dbc;
modelRoot.addPropertyChangeListener(this);
}
public void setServerControlInterface() {
// Check that there is a file to load..
saveGameAction.setEnabled(true);
Enumeration<Action> e = targetTicksPerSecondActions.getActions();
targetTicksPerSecondActions.setPerformActionOnSetSelectedItem(false);
while (e.hasMoreElements()) {
e.nextElement().setEnabled(true);
}
String[] mapNames = NewGameMessage2Server.getMapNames();
Action[] actions = new Action[mapNames.length];
for (int j = 0; j < actions.length; j++) {
actions[j] = new NewGameAction(mapNames[j]);
actions[j].setEnabled(true);
}
selectMapActions = new ActionAdapter(actions);
newGameAction.setEnabled(true);
}
}

/**
* This class returns the Java System Properties as an HTML table.
*
* @author Luke
*
*/
public class ShowJavaProperties {
public static final int TABLE_WIDTH = 500;
private static final Logger logger = Logger
.getLogger(ShowJavaProperties.class.getName());
public static void main(String[] args) {
logger.info(getPropertiesHtmlString());
}
public static String getPropertiesHtmlString() {
Properties p = System.getProperties();
StringBuffer sb = new StringBuffer();
/* We set the width of the table so that its text word-wraps. */
sb.append("<html><h3>Java System Properties</h3><table width =\""
+ TABLE_WIDTH + "\" align = \"left\" valign = \"top\">\n");
Enumeration keys = p.keys();
//We use an ArrayList so that the keys can be sorted into alphabetical order
ArrayList<String> list = new ArrayList<String>();
while (keys.hasMoreElements()) {
String key = (String) keys.nextElement();
list.add(key);
}
Collections.sort(list);
for(String key : list){
String value = p.getProperty(key);
/*
* Insert a line break after each ";". This makes reading classpath
* elements easier.
*/
value = value.replaceAll(";", ";<br>");
sb
.append("<tr><td>" + key + " </td><td> " + value
+ "</td></tr>\n");
}
sb.append("</table></html>\n");
return sb.toString();
}
}

/**
* This class provides the UI model for building a station. The mode of
* operation is as follows:
* <ol>
* <li>Select a station to build by calling ActionPerformed() on the choose
* Action.
* <li>Set the position to build.
* <li>call actionPerformed on the build Action
* <li> alternatively, call actionPerformed on the cancel Action
* </ol>
*
* @author rob
*/
public class StationBuildModel {
/*
* 100 010 001 = 0x111
*/
private static final int trackTemplate = TrackConfiguration
.from9bitTemplate(0x111).get9bitTemplate();
/**
* Vector of StationBuildAction. Actions which represent stations which can
* be built
*/
private final Vector<Action> stationChooseActions = new Vector<Action>();
/**
* Whether the station's position can should change when the mouse moves.
*/
private boolean positionFollowsMouse = true;
private final StationBuildAction stationBuildAction = new StationBuildAction();
private final StationCancelAction stationCancelAction = new StationCancelAction();
private final StationBuilder stationBuilder;
private final ModelRoot modelRoot;
private final HashMap<Integer, Action> id2Action = new HashMap<Integer, Action>();
public StationBuildModel(StationBuilder sb, RenderersRoot rr, ModelRoot mr) {
stationBuilder = sb;
modelRoot = mr;
ReadOnlyWorld world = modelRoot.getWorld();
for (int i = 0; i < world.size(SKEY.TRACK_RULES); i++) {
final TrackRule trackRule = (TrackRule) world.get(
SKEY.TRACK_RULES, i);
if (trackRule.isStation()) {
TrackPieceRenderer renderer = rr.getTrackPieceView(i);
StationChooseAction action = new StationChooseAction(i);
String trackType = trackRule.getTypeName();
Money price = trackRule.getFixedCost();
String shortDescrpt = Utils.capitalizeEveryWord(trackType)
+ " $" + price.toString();
action.putValue(Action.SHORT_DESCRIPTION, shortDescrpt);
action.putValue(Action.NAME, "Build " + trackType);
action.putValue(Action.SMALL_ICON, new ImageIcon(renderer
.getTrackPieceIcon(trackTemplate)));
stationChooseActions.add(action);
id2Action.put(new Integer(i), action);
}
}
}
public Action getStationChooseAction(Integer ruleID) {
return id2Action.get(ruleID);
}
public Action[] getStationChooseActions() {
return stationChooseActions.toArray(new Action[stationChooseActions.size()]);
}
private class StationChooseAction extends AbstractAction {
private static final long serialVersionUID = 3257290240279458098L;
private final int actionId;
public StationChooseAction(int actionId) {
this.actionId = actionId;
}
public void actionPerformed(ActionEvent e) {
stationBuilder.setStationType(actionId);
TrackRule trackRule = (TrackRule) modelRoot.getWorld().get(
SKEY.TRACK_RULES, actionId);
// Show the relevant station radius when the station type's menu
// item
// gets focus.
stationBuildAction.putValue(StationBuildAction.STATION_RADIUS_KEY,
new Integer(trackRule.getStationRadius()));
stationBuildAction.setEnabled(true);
}
}
private class StationCancelAction extends AbstractAction {
private static final long serialVersionUID = 3256441421581203252L;
public void actionPerformed(ActionEvent e) {
stationBuildAction.setEnabled(false);
}
}
/**
* This action builds the station.
*/
public class StationBuildAction extends AbstractAction {
private static final long serialVersionUID = 3905236827739926833L;
/**
* This key can be used to set the position where the station is to be
* built as a Point object.
*/
public final static String STATION_POSITION_KEY = "STATION_POSITION_KEY";
/**
* This key can be used to retrieve the radius of the currently selected
* station as an Integer value. Don't bother writing to it!
*/
public final static String STATION_RADIUS_KEY = "STATION_RADIUS_KEY";
StationBuildAction() {
setEnabled(false);
}
public void actionPerformed(ActionEvent e) {
Point value = (Point) stationBuildAction
.getValue(StationBuildAction.STATION_POSITION_KEY);
MoveStatus ms = stationBuilder.buildStation(new ImPoint(value.x,
value.y));
String message = null;
if (ms.isOk()) {
stationBuildAction.setEnabled(false);
} else {
message = ms.message;
}
modelRoot.setProperty(ModelRoot.Property.CURSOR_MESSAGE, message);
}
}
public boolean canBuildStationHere() {
Point p = (Point) stationBuildAction
.getValue(StationBuildAction.STATION_POSITION_KEY);
return stationBuilder.tryBuildingStation(new ImPoint(p.x, p.y)).ok;
}
public Action getStationCancelAction() {
return stationCancelAction;
}
public StationBuildAction getStationBuildAction() {
return stationBuildAction;
}
public boolean isPositionFollowsMouse() {
return positionFollowsMouse;
}
public void setPositionFollowsMouse(boolean positionFollowsMouse) {
this.positionFollowsMouse = positionFollowsMouse;
}
}

/**
* This JPanel displays the supply and demand at a station.
*
* @author Luke
*/
public class StationInfoJPanel extends JPanel implements View,
WorldListListener {
private static final long serialVersionUID = 4050759377680150585L;
private ReadOnlyWorld w;
private ModelRoot modelRoot;
private WorldIterator wi;
/**
* The index of the cargoBundle associated with this station.
*/
private int cargoBundleIndex;
public StationInfoJPanel() {
initComponents();
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
private void initComponents() {// GEN-BEGIN:initComponents
java.awt.GridBagConstraints gridBagConstraints;
jLabel1 = new javax.swing.JLabel();
nextStation = new javax.swing.JButton();
previousStation = new javax.swing.JButton();
close = new javax.swing.JButton();
setLayout(new java.awt.GridBagLayout());
setMinimumSize(new java.awt.Dimension(250, 177));
jLabel1.setFont(new java.awt.Font("Dialog", 0, 10));
jLabel1
.setText("<html>\n<h4 align=\"center\">Supply and Demand at stationName</h4>\n<table width=\"100%\" border=\"0\" cellspacing=\"0\" cellpadding=\"2\">\n <tr>\n <td>&nbsp;</td>\n <td>Will pay<br>for</td>\n <td>Supplies<br>(cars per year)</td>\n <td>Waiting for pickup<br>(car loads)</td>\n </tr>\n <tr>\n <td>Mail</td>\n <td>Yes</td>\n <td>&nbsp;</td>\n <td>&nbsp;</td>\n </tr>\n <tr>\n <td>Passengers</td>\n <td>No</td>\n <td>3</td>\n <td>2.5</td>\n </tr>\n \n</table>\n\n</html>");
jLabel1.setVerticalAlignment(javax.swing.SwingConstants.TOP);
jLabel1.setAlignmentY(0.0F);
jLabel1.setVerticalTextPosition(javax.swing.SwingConstants.TOP);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridwidth = 3;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTH;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
gridBagConstraints.insets = new java.awt.Insets(8, 8, 4, 8);
add(jLabel1, gridBagConstraints);
nextStation.setText("next ->");
nextStation.setMargin(new java.awt.Insets(0, 0, 0, 0));
nextStation.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
nextStationActionPerformed(evt);
}
});
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 2;
gridBagConstraints.gridy = 1;
gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
add(nextStation, gridBagConstraints);
previousStation.setText("<- previous");
previousStation.setMargin(new java.awt.Insets(0, 0, 0, 0));
previousStation.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
previousStationActionPerformed(evt);
}
});
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
add(previousStation, gridBagConstraints);
close.setText("close");
close.setMargin(new java.awt.Insets(0, 0, 0, 0));
close.setMaximumSize(new java.awt.Dimension(65, 22));
close.setMinimumSize(new java.awt.Dimension(65, 22));
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 1;
gridBagConstraints.gridy = 1;
gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
add(close, gridBagConstraints);
}// GEN-END:initComponents
private void previousStationActionPerformed(java.awt.event.ActionEvent evt) {
// GEN-FIRST:event_previousStationActionPerformed
// Add your handling code here:
if (wi.previous()) {
ImPoint p = new ImPoint(((StationModel) wi.getElement())
.getStationX(), ((StationModel) wi.getElement())
.getStationY());
this.modelRoot.setProperty(ModelRoot.Property.CURSOR_POSITION, p);
display();
} else {
throw new IllegalStateException();
}
} // GEN-LAST:event_previousStationActionPerformed
private void nextStationActionPerformed(java.awt.event.ActionEvent evt) {
// GEN-FIRST:event_nextStationActionPerformed
// Add your handling code here:
if (wi.next()) {
ImPoint p = new ImPoint(((StationModel) wi.getElement())
.getStationX(), ((StationModel) wi.getElement())
.getStationY());
this.modelRoot.setProperty(ModelRoot.Property.CURSOR_POSITION, p);
display();
} else {
throw new IllegalStateException();
}
} // GEN-LAST:event_nextStationActionPerformed
public void setup(ModelRoot mr, RenderersRoot vl, Action al) {
this.wi = new NonNullElements(KEY.STATIONS, mr.getWorld(), mr
.getPrincipal());
addComponentListener(componentListener);
this.w = mr.getWorld();
this.modelRoot = mr;
this.close.addActionListener(al);
}
public void setStation(int stationNumber) {
this.wi.gotoIndex(stationNumber);
display();
}
private void display() {
if (wi.getRowID() > 0) {
this.previousStation.setEnabled(true);
} else {
this.previousStation.setEnabled(false);
}
if (wi.getRowID() < (wi.size() - 1)) {
this.nextStation.setEnabled(true);
} else {
this.nextStation.setEnabled(false);
}
int stationNumber = wi.getIndex();
String label;
if (stationNumber != WorldIterator.BEFORE_FIRST) {
StationModel station = (StationModel) w.get(modelRoot.getPrincipal(),
KEY.STATIONS, stationNumber);
FreerailsTile tile = (FreerailsTile) w
.getTile(station.x, station.y);
String stationTypeName = tile.getTrackPiece().getTrackRule().getTypeName();
cargoBundleIndex = station.getCargoBundleID();
ImmutableCargoBundle cargoWaiting = (ImmutableCargoBundle) w.get(
modelRoot
.getPrincipal(), KEY.CARGO_BUNDLES, station.getCargoBundleID());
String title = "<h2 align=\"center\">" + station.getStationName()
+ " (" + stationTypeName + ")</h2>";
String table = "<table width=\"100%\" border=\"0\" cellspacing=\"0\" cellpadding=\"3\"><tr><td>&nbsp;</td>\n <td>Will pay for</td>\n <td>Supplies / cars per year</td><td>Waiting for pickup / car loads</td> </tr>";
for (int i = 0; i < w.size(SKEY.CARGO_TYPES); i++) {
// get the values
CargoType cargoType = (CargoType) w.get(SKEY.CARGO_TYPES, i);
String demanded = (station.getDemand().isCargoDemanded(i) ? "Yes"
: "No");
int amountSupplied = station.getSupply().getSupply(i);
String supply = (amountSupplied > 0) ? String
.valueOf(amountSupplied
/ WagonType.UNITS_OF_CARGO_PER_WAGON)
: "&nbsp;";
int amountWaiting = cargoWaiting.getAmount(i);
String waiting = (amountWaiting > 0) ? String
.valueOf(amountWaiting
/ WagonType.UNITS_OF_CARGO_PER_WAGON)
: "&nbsp;";
// build the html
table += "<tr>";
table += "<td>" + cargoType.getDisplayName() + "</td>";
table += "<td>" + demanded + "</td>";
table += "<td>" + supply + "</td>";
table += "<td>" + waiting + "</td>";
table += "</tr>";
}
table += "</table>";
label = "<html>" + title + table + "</html>";
} else {
cargoBundleIndex = WorldIterator.BEFORE_FIRST;
label = "<html><h2 align=\"center\">No Station "
+ "Selected</h2></html>";
}
jLabel1.setText(label);
this.repaint();
}
private final ComponentAdapter componentListener = new ComponentAdapter() {
@Override
public void componentHidden(ComponentEvent e) {
}
@Override
public void componentShown(ComponentEvent e) {
int i = wi.getIndex();
wi.reset();
if (i != WorldIterator.BEFORE_FIRST) {
wi.gotoIndex(i);
}
display();
}
};
private FreerailsSerializable lastCargoBundle = null;
@Override
protected void paintComponent(Graphics g) {
/* We need to update if the cargo bundle has changed. */
FreerailsPrincipal playerPrincipal = this.modelRoot.getPrincipal();
/*
* Avoid a array out of bounds exception when there are no stations and
* the stations tab is visible.
*/
if (w.boundsContain(playerPrincipal, KEY.CARGO_BUNDLES,
cargoBundleIndex)) {
FreerailsSerializable currentCargoBundle = w.get(playerPrincipal,
KEY.CARGO_BUNDLES, this.cargoBundleIndex);
if (lastCargoBundle != currentCargoBundle) {
this.display();
lastCargoBundle = currentCargoBundle;
}
}
super.paintComponent(g);
}
private void reactToUpdate(KEY key, int changedIndex, boolean isAddition) {
if (!isVisible()) {
return;
}
int currentIndex = wi.getIndex();
if (key == KEY.CARGO_BUNDLES) {
if (changedIndex == cargoBundleIndex) {
/* update our cargo bundle */
display();
return;
}
} else if (key == KEY.STATIONS) {
wi.reset();
if (currentIndex != WorldIterator.BEFORE_FIRST) {
if (currentIndex < wi.size()) {
wi.gotoIndex(currentIndex);
} else {
currentIndex = WorldIterator.BEFORE_FIRST;
}
}
if (isAddition && wi.getIndex() == WorldIterator.BEFORE_FIRST) {
if (wi.next()) {
display();
}
}
if (currentIndex == changedIndex
|| currentIndex == WorldIterator.BEFORE_FIRST) {
display();
}
}
return;
}
public void listUpdated(KEY key, int index, FreerailsPrincipal principal) {
if (modelRoot.getPrincipal().equals(principal))
reactToUpdate(key, index, false);
}
public void itemAdded(KEY key, int index, FreerailsPrincipal principal) {
if (modelRoot.getPrincipal().equals(principal))
reactToUpdate(key, index, true);
}
public void itemRemoved(KEY key, int index, FreerailsPrincipal principal) {
if (modelRoot.getPrincipal().equals(principal))
reactToUpdate(key, index, false);
}
void removeCloseButton() {
this.remove(close);
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JButton close;
private javax.swing.JLabel jLabel1;
private javax.swing.JButton nextStation;
private javax.swing.JButton previousStation;
// End of variables declaration//GEN-END:variables
}

/**
* This class implements a cursor which can be used to place a station on the
* map. Mode of operation:
* <ol>
* <li>User selects a station to place, which sets the current cursor to the
* station placement cursor.
* <li>User highlights desired build location with the mouse, boundary of the
* station radius is highlighted. If the station cannot be built, the boundary
* highlights in red.
* <li>User places station with the left mouse button.
* <li>User may cancel placement by using the right mouse button
* <li>Cursor fires the actionPerformed causing the station to be built.
* </ol>
* When the StationBuildAction is no longer enabled, the owner reverts to the
* regular cursor type. TODO scroll the area when the mouse hovers at the edge
* of the map.
*
* @author rob
*/
public class StationPlacementCursor extends MouseInputAdapter {
public static void wireUp(ActionRoot actionRoot, StationRadiusRenderer srr,
MapViewJComponent mapView) {
StationPlacementCursor spc = new StationPlacementCursor(actionRoot,
srr, mapView);
spc.init();
}
private final PropertyChangeListener buildActionListener = new PropertyChangeListener() {
public void propertyChange(PropertyChangeEvent e) {
if (e.getPropertyName().equals(
StationBuildModel.StationBuildAction.STATION_POSITION_KEY)) {
/* update the renderer pos */
Point p = (Point) e.getNewValue();
stationRadiusRenderer.setPosition(p.x, p.y);
if (stationBuildModel.canBuildStationHere()) {
stationRadiusRenderer
.setBorderColor(StationRadiusRenderer.COLOR_OK);
} else {
stationRadiusRenderer
.setBorderColor(StationRadiusRenderer.COLOR_CANNOT_BUILD);
}
} else if (e.getPropertyName().equals(
StationBuildModel.StationBuildAction.STATION_RADIUS_KEY)) {
Integer radius = (Integer) e.getNewValue();
stationRadiusRenderer.setRadius(radius.intValue());
}
boolean enabled = stationBuildModel.getStationBuildAction()
.isEnabled();
if (buildEnabled != enabled) {
if (enabled) {
mapView.addMouseListener(StationPlacementCursor.this);
mapView.addMouseMotionListener(StationPlacementCursor.this);
stationRadiusRenderer.show();
} else {
stationRadiusRenderer.hide();
mapView.removeMouseListener(StationPlacementCursor.this);
mapView
.removeMouseMotionListener(StationPlacementCursor.this);
}
buildEnabled = enabled;
}
}
};
private boolean buildEnabled;
private final MapViewJComponent mapView;
private final float scale;
private final StationBuildModel stationBuildModel;
private final StationRadiusRenderer stationRadiusRenderer;
private StationPlacementCursor(ActionRoot actionRoot,
StationRadiusRenderer srr, MapViewJComponent mapView) {
scale = mapView.getScale();
this.mapView = mapView;
stationBuildModel = actionRoot.getStationBuildModel();
stationRadiusRenderer = srr;
buildEnabled = stationBuildModel.getStationBuildAction().isEnabled();
}
private void init() {
if (buildEnabled) {
mapView.addMouseListener(this);
mapView.addMouseMotionListener(this);
stationRadiusRenderer.show();
} else {
stationRadiusRenderer.hide();
mapView.removeMouseListener(this);
mapView.removeMouseMotionListener(this);
}
stationBuildModel.getStationBuildAction().addPropertyChangeListener(
buildActionListener);
}
@Override
public void mouseClicked(MouseEvent e) {
int button = e.getButton();
if (button == MouseEvent.BUTTON1) {
/* attempt to build */
stationBuildModel.getStationBuildAction().actionPerformed(
new ActionEvent(this, ActionEvent.ACTION_PERFORMED, ""));
} else if (button == MouseEvent.BUTTON3) {
/* cancel the build */
stationBuildModel.getStationCancelAction().actionPerformed(
new ActionEvent(this, ActionEvent.ACTION_PERFORMED, ""));
}
}
@Override
public void mouseEntered(MouseEvent e) {
stationRadiusRenderer.show();
}
@Override
public void mouseExited(MouseEvent e) {
stationRadiusRenderer.hide();
}
@Override
public void mouseMoved(MouseEvent e) {
if (stationBuildModel.isPositionFollowsMouse()) {
Point p = e.getPoint();
Point mapCoord = new Point((int) (p.x / scale), (int) (p.y / scale));
stationBuildModel.getStationBuildAction().putValue(
StationBuildModel.StationBuildAction.STATION_POSITION_KEY,
mapCoord);
}
}
}

/**
* This JPanel shows information on a terrain type.
*
* @author Luke
*/
public class TerrainInfoJPanel extends javax.swing.JPanel {
private static final long serialVersionUID = 3258131375164045363L;
private RenderersRoot rr;
private ReadOnlyWorld w;
public TerrainInfoJPanel() {
initComponents();
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
private void initComponents() {// GEN-BEGIN:initComponents
java.awt.GridBagConstraints gridBagConstraints;
terrainImage = new javax.swing.JLabel();
terrainName = new javax.swing.JLabel();
terrainDescription = new javax.swing.JLabel();
setLayout(new java.awt.GridBagLayout());
terrainImage.setIcon(new javax.swing.ImageIcon(getClass().getResource(
"/jfreerails/client/graphics/terrain/City_0.png")));
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.insets = new java.awt.Insets(8, 8, 4, 4);
add(terrainImage, gridBagConstraints);
terrainName.setFont(new java.awt.Font("Dialog", 1, 14));
terrainName.setText("City");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 1;
gridBagConstraints.gridy = 0;
gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 8);
add(terrainName, gridBagConstraints);
terrainDescription.setFont(new java.awt.Font("Dialog", 0, 12));
terrainDescription
.setText("<html>\n<p>Right-of-Way costs X per mile. </p>\n<table width=\"75%\" >\n <tr> \n <td><strong>Supplies:</strong></td>\n <td>&nbsp;</td>\n </tr>\n <tr> \n <td>Mail </td>\n <td>2</td>\n </tr>\n <tr> \n <td>Passengers</td>\n <td>2</td>\n </tr>\n <tr> \n <td> <strong>Demands</strong></td>\n <td>&nbsp;</td>\n </tr>\n <tr> \n <td>Mail</td>\n <td>&nbsp;</td>\n </tr>\n <tr> \n <td>Passengers</td>\n <td>&nbsp;</td>\n </tr>\n <tr> \n <td><strong>Converts</strong></td>\n <td>&nbsp;</td>\n </tr>\n <tr> \n <td>Livestock to Food</td>\n <td>&nbsp;</td>\n </tr>\n <tr>\n <td>Steel to Goods</td>\n <td>&nbsp;</td>\n </tr>\n</table>\n</html>");
terrainDescription.setVerticalAlignment(javax.swing.SwingConstants.TOP);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.gridwidth = 2;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
gridBagConstraints.insets = new java.awt.Insets(4, 8, 4, 8);
add(terrainDescription, gridBagConstraints);
}// GEN-END:initComponents
public void setup(ReadOnlyWorld w, RenderersRoot vl) {
this.w = w;
this.rr = vl;
}
public void setTerrainType(int typeNumber) {
TerrainType type = (TerrainType) w.get(SKEY.TERRAIN_TYPES, typeNumber);
String row = "<p>Right-of-Way costs $" + type.getRightOfWay()
+ " per mile. </p>";
String tableString = "";
int cargosProduced = type.getProduction().size();
int cargosConsumed = type.getConsumption().size();
int cargosConverted = type.getConversion().size();
if ((cargosProduced + cargosConsumed + cargosConverted) > 0) {
// if the terrain type produces, consumes, or converts anything.
tableString = "<table width=\"75%\" >";
if (cargosProduced != 0) {
tableString += "<tr> <td><strong>Supplies</strong></td> <td>&nbsp;</td> </tr>";
for (int i = 0; i < cargosProduced; i++) {
Production p = type.getProduction().get(i);
CargoType c = (CargoType) w.get(SKEY.CARGO_TYPES, p
.getCargoType());
String supply = String.valueOf(p.getRate()
/ WagonType.UNITS_OF_CARGO_PER_WAGON);
tableString += "<tr> <td>" + c.getDisplayName()
+ " </td><td>" + supply + "</td></tr>";
}
}
if (cargosConsumed != 0) {
tableString += "<tr> <td><strong>Demands</strong></td> <td>&nbsp;</td> </tr>";
for (int i = 0; i < cargosConsumed; i++) {
Consumption p = type.getConsumption().get(i);
CargoType c = (CargoType) w.get(SKEY.CARGO_TYPES, p
.getCargoType());
tableString += "<tr> <td>" + c.getDisplayName()
+ " </td><td>&nbsp;</td></tr>";
}
}
if (cargosConverted != 0) {
tableString += "<tr> <td><strong>Converts</strong></td> <td>&nbsp;</td> </tr>";
for (int i = 0; i < cargosConverted; i++) {
Conversion p = type.getConversion().get(i);
CargoType input = (CargoType) w.get(SKEY.CARGO_TYPES, p
.getInput());
CargoType output = (CargoType) w.get(SKEY.CARGO_TYPES, p
.getOutput());
tableString += "<tr> <td colspan=\"2\">"
+ input.getDisplayName() + " to "
+ output.getDisplayName() + "</td></tr>";
}
}
tableString += "</table> ";
}
String labelString = "<html>" + row + tableString + "</html>";
terrainDescription.setText(labelString);
terrainName.setText(type.getDisplayName());
Image tileIcon = rr.getTileViewWithNumber(typeNumber)
.getDefaultIcon();
terrainImage.setIcon(new ImageIcon(tileIcon));
repaint();
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JLabel terrainDescription;
private javax.swing.JLabel terrainImage;
private javax.swing.JLabel terrainName;
// End of variables declaration//GEN-END:variables
}

/**
* This JPanel displays a side-on view of a train and a summary of the cargo
* that it is carrying.
*
* @author Luke Lindsay
*/
public class TrainDescriptionJPanel extends javax.swing.JPanel implements View{
private static final long serialVersionUID = 3977018444325664049L;
private ReadOnlyWorld w;
private FreerailsPrincipal principal;
private int trainNumber = -1;
private FreerailsSerializable lastTrain, lastCargoBundle;
public TrainDescriptionJPanel() {
initComponents();
}
@Override
protected void paintComponent(Graphics arg0) {
//Check whether the train or its cargo have changed since the last call to this method.
updateIfNecessary();
super.paintComponent(arg0);
}
private void updateIfNecessary() {
TrainModel train = (TrainModel) w.get(principal, KEY.TRAINS,
trainNumber);
for (int i = 0; i < train.getNumberOfWagons(); i++) {
// this.sideOnTrainViewJPanel1.addWagon(train.getWagon(i));
}
int cargoBundleID = train.getCargoBundleID();
FreerailsSerializable cb = w.get(
principal, KEY.CARGO_BUNDLES, cargoBundleID);
if(train != lastTrain || cb != lastCargoBundle)
displayTrain(trainNumber);
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
private void initComponents() {// GEN-BEGIN:initComponents
java.awt.GridBagConstraints gridBagConstraints;
jLabel1 = new javax.swing.JLabel();
trainViewJPanel1 = new jfreerails.client.view.TrainListCellRenderer();
setLayout(new java.awt.GridBagLayout());
setBorder(new javax.swing.border.TitledBorder("Current Details"));
setPreferredSize(new java.awt.Dimension(250, 97));
jLabel1.setFont(new java.awt.Font("Dialog", 0, 12));
jLabel1
.setText("<html><head></head><body>Trains X: 20 passengers, 15 tons of mfg goods, 12 sacks of mail, and 7 tons of livestock.</body></html>");
jLabel1.setMinimumSize(new java.awt.Dimension(250, 17));
jLabel1.setHorizontalTextPosition(javax.swing.SwingConstants.LEADING);
jLabel1.setVerticalTextPosition(javax.swing.SwingConstants.TOP);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
add(jLabel1, gridBagConstraints);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
add(trainViewJPanel1, gridBagConstraints);
}// GEN-END:initComponents
public void setup(ModelRoot mr, RenderersRoot vl,
Action closeAction) {
this.trainViewJPanel1.setup(mr, vl, closeAction);
trainViewJPanel1.setHeight(30);
trainViewJPanel1.setCenterTrain(true);
this.w = mr.getWorld();
principal = mr.getPrincipal();
}
public void displayTrain(int newTrainNumber) {
NonNullElements it = new NonNullElements(KEY.TRAINS, w, principal);
it.gotoIndex(newTrainNumber);
this.trainNumber = newTrainNumber;
trainViewJPanel1.display(newTrainNumber);
TrainModel train = (TrainModel) w.get(principal, KEY.TRAINS,
newTrainNumber);
for (int i = 0; i < train.getNumberOfWagons(); i++) {
// this.sideOnTrainViewJPanel1.addWagon(train.getWagon(i));
}
int cargoBundleID = train.getCargoBundleID();
ImmutableCargoBundle cb = (ImmutableCargoBundle) w.get(
principal, KEY.CARGO_BUNDLES, cargoBundleID);
String s = "Train #" + it.getNaturalNumber() + ": ";
int numberOfTypesInBundle = 0;
for (int i = 0; i < w.size(SKEY.CARGO_TYPES); i++) {
int amount = cb.getAmount(i);
if (0 != amount) {
CargoType ct = (CargoType) w.get(SKEY.CARGO_TYPES, i);
String cargoTypeName = ct.getDisplayName();
if (0 != numberOfTypesInBundle) {
s += "; ";
}
numberOfTypesInBundle++;
s += cargoTypeName + " (" + amount + ")";
}
}
if (0 == numberOfTypesInBundle) {
s += "no cargo";
}
s += ".";
this.jLabel1.setText(s);
this.lastCargoBundle = cb;
this.lastTrain = train;
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JLabel jLabel1;
private jfreerails.client.view.TrainListCellRenderer trainViewJPanel1;
// End of variables declaration//GEN-END:variables
}

/**
* JPanel that displays info on a train; it is composed of a
* {@link TrainScheduleJPanel} and {@link TrainDescriptionJPanel}.
*
* @author Luke Lindsay
*/
public class TrainDialogueJPanel extends javax.swing.JPanel implements View,
WorldListListener {
private static final long serialVersionUID = 3257005466801157938L;
private static final Logger logger = Logger
.getLogger(TrainDialogueJPanel.class.getName());
private WorldIterator wi;
private ReadOnlyWorld w;
private FreerailsPrincipal principal;
public TrainDialogueJPanel() {
initComponents();
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
private void initComponents() {// GEN-BEGIN:initComponents
java.awt.GridBagConstraints gridBagConstraints;
newTrainScheduleJPanel1 = new jfreerails.client.view.TrainScheduleJPanel();
trainDetailsJPanel1 = new TrainDescriptionJPanel();
previousJButton = new javax.swing.JButton();
nextJButton = new javax.swing.JButton();
trainListJButton = new javax.swing.JButton();
closeJButton = new javax.swing.JButton();
setLayout(new java.awt.GridBagLayout());
setPreferredSize(new java.awt.Dimension(510, 400));
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.gridwidth = 4;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
add(newTrainScheduleJPanel1, gridBagConstraints);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridwidth = 4;
gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
gridBagConstraints.weightx = 1.0;
add(trainDetailsJPanel1, gridBagConstraints);
previousJButton.setText("last");
previousJButton.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
previousJButtonActionPerformed(evt);
}
});
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 2;
gridBagConstraints.insets = new java.awt.Insets(5, 5, 5, 5);
add(previousJButton, gridBagConstraints);
nextJButton.setText("next");
nextJButton.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
nextJButtonActionPerformed(evt);
}
});
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 1;
gridBagConstraints.gridy = 2;
gridBagConstraints.insets = new java.awt.Insets(5, 5, 5, 5);
add(nextJButton, gridBagConstraints);
trainListJButton.setText("Train list");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 2;
gridBagConstraints.gridy = 2;
gridBagConstraints.insets = new java.awt.Insets(5, 5, 5, 5);
add(trainListJButton, gridBagConstraints);
closeJButton.setText("Close");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 3;
gridBagConstraints.gridy = 2;
gridBagConstraints.insets = new java.awt.Insets(5, 5, 5, 5);
add(closeJButton, gridBagConstraints);
}// GEN-END:initComponents
private void previousJButtonActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_previousJButtonActionPerformed
// Add your handling code here:
if (wi.previous()) {
display(wi.getIndex());
} else {
logger.warning("Couldn't get previous");
}
}// GEN-LAST:event_previousJButtonActionPerformed
private void nextJButtonActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_nextJButtonActionPerformed
// Add your handling code here:
if (wi.next()) {
display(wi.getIndex());
} else {
logger.warning("Couldn't get next");
}
}// GEN-LAST:event_nextJButtonActionPerformed
public void setup(ModelRoot mr, RenderersRoot vl, Action al) {
newTrainScheduleJPanel1.setup(mr, vl, al);
trainDetailsJPanel1.setup(mr, vl, al);
this.setCancelButtonActionListener(al);
this.principal = mr.getPrincipal();
this.w = mr.getWorld();
}
public void display(int trainNumber) {
wi = new NonNullElements(KEY.TRAINS, w, principal);
wi.gotoIndex(trainNumber);
if (wi.getRowID() > 0) {
this.previousJButton.setEnabled(true);
} else {
this.previousJButton.setEnabled(false);
}
if (wi.getRowID() < (wi.size() - 1)) {
this.nextJButton.setEnabled(true);
} else {
this.nextJButton.setEnabled(false);
}
newTrainScheduleJPanel1.display(trainNumber);
trainDetailsJPanel1.displayTrain(trainNumber);
}
public void listUpdated(KEY key, int index, FreerailsPrincipal p) {
newTrainScheduleJPanel1.listUpdated(key, index, p);
}
public void itemAdded(KEY key, int index, FreerailsPrincipal p) {
}
public void itemRemoved(KEY key, int index, FreerailsPrincipal p) {
}
void setTrainDetailsButtonActionListener(ActionListener l) {
ActionListener[] oldListeners = trainListJButton.getActionListeners();
for (int i = 0; i < oldListeners.length; i++) {
trainListJButton.removeActionListener(oldListeners[i]);
}
this.trainListJButton.addActionListener(l);
}
/**
* Removes any existing ActionListener listeners from the cancel button,
* then adds the specified one.
*/
void setCancelButtonActionListener(ActionListener l) {
ActionListener[] oldListeners = closeJButton.getActionListeners();
for (int i = 0; i < oldListeners.length; i++) {
closeJButton.removeActionListener(oldListeners[i]);
}
this.closeJButton.addActionListener(l);
}
// Variables declaration - do not modify//GEN-BEGIN:variables
javax.swing.JButton closeJButton;
jfreerails.client.view.TrainScheduleJPanel newTrainScheduleJPanel1;
javax.swing.JButton nextJButton;
javax.swing.JButton previousJButton;
jfreerails.client.view.TrainDescriptionJPanel trainDetailsJPanel1;
javax.swing.JButton trainListJButton;
// End of variables declaration//GEN-END:variables
}

/**
* This JPanel displays an engine and a number of wagons.
*
* @author Luke Lindsay
*/
public class TrainListCellRenderer extends JPanel implements View, ListCellRenderer,
WorldListListener {
private static final long serialVersionUID = 3546076964969591093L;
private ReadOnlyWorld w;
private RenderersRoot vl;
private int trainNumber = -1;
private int scheduleOrderNumber;
private int scheduleID = -1;
private int height = 100;
private FreerailsPrincipal principal;
private Image[] images = new Image[0];
/**
* Whether this JPanel should one of the trains orders from the schedule
* instead of the trains current formation.
*/
private boolean showingOrder = false;
/**
* If true, the train is drawn in the center to the JPanel; if false, the
* train is drawn left aligned.
*/
private boolean centerTrain = false;
private int trainWidth = 0;
private boolean selected = false;
private final Color backgroundColor = (java.awt.Color) javax.swing.UIManager.getDefaults().get(
"List.background");
private final Color selectedColor = (java.awt.Color) javax.swing.UIManager.getDefaults().get(
"List.selectionBackground");
private final Color selectedColorNotFocused = Color.LIGHT_GRAY;
public TrainListCellRenderer() {
this.setOpaque(false);
}
public TrainListCellRenderer(ModelRoot mr, RenderersRoot vl) {
setup(mr, vl, null);
this.setBackground(backgroundColor);
}
public void setCenterTrain(boolean b) {
this.centerTrain = b;
}
public void display(int newTrainNumber) {
showingOrder = false;
this.trainNumber = newTrainNumber;
TrainModel train = (TrainModel) w.get(principal, KEY.TRAINS, trainNumber);
display(train.getEngineType(), train.getConsist());
resetPreferredSize();
}
private void display(int engine, ImInts wagons){
images = new Image[1 + wagons.size()];
// images[0] = vl.getTrainImages().getSideOnEngineImage(
// train.getEngineType(), height);
String engineFilename = vl.getEngineImages(engine).sideOnFileName;
try {
images[0] = vl.getScaledImage(engineFilename, height);
} catch (IOException e) {
e.printStackTrace();
throw new IllegalArgumentException(engineFilename);
}
for (int i = 0; i < wagons.size(); i++) {
// images[i + 1] = vl.getTrainImages().getSideOnWagonImage(
// order.consist.get(i), height);
int wagonType = wagons.get(i);
String wagonFilename = vl.getWagonImages(wagonType).sideOnFileName;
try {
images[i + 1] = vl.getScaledImage(wagonFilename, height);
} catch (IOException e) {
e.printStackTrace();
throw new IllegalArgumentException(wagonFilename);
}
}
}
public void display(int newTrainNumber, int newScheduleOrderID) {
showingOrder = true;
this.trainNumber = newTrainNumber;
this.scheduleOrderNumber = newScheduleOrderID;
TrainModel train = (TrainModel) w.get(principal, KEY.TRAINS, trainNumber);
this.scheduleID = train.getScheduleID();
ImmutableSchedule s = (ImmutableSchedule) w.get(principal, KEY.TRAIN_SCHEDULES, scheduleID);
TrainOrdersModel order = s.getOrder(newScheduleOrderID);
// Set up the array of images.
if (null != order.consist) {
display(train.getEngineType(), order.consist);
} else {
images = new Image[0];
}
resetPreferredSize();
}
private void resetPreferredSize() {
int width = 0;
for (int i = 0; i < images.length; i++) {
width += images[i].getWidth(null);
}
this.trainWidth = width;
this.setPreferredSize(new Dimension(width, height));
}
public void setup(ModelRoot mr, RenderersRoot vl, Action closeAction) {
this.w = mr.getWorld();
this.vl = vl;
this.principal = mr.getPrincipal();
}
public Component getListCellRendererComponent(JList list, Object value, int index,
boolean isSelected, boolean cellHasFocus) {
int trainID = NonNullElements.row2index(w, KEY.TRAINS, principal, index);
display(trainID);
selected = isSelected;
if (selected) {
if (list.isFocusOwner()) {
setBackground(selectedColor);
} else {
setBackground(selectedColorNotFocused);
}
} else {
setBackground(backgroundColor);
}
return this;
}
@Override
public int getHeight() {
return height;
}
public void setHeight(int i) {
height = i;
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
int x = 0;
if (this.centerTrain) {
x = (this.getWidth() - this.trainWidth) / 2;
}
for (int i = 0; i < images.length; i++) {
g.drawImage(images[i], x, 0, null);
x += images[i].getWidth(null);
}
}
public void listUpdated(KEY key, int index, FreerailsPrincipal p) {
if (showingOrder) {
if (KEY.TRAIN_SCHEDULES == key && this.scheduleID == index) {
this.display(this.trainNumber, this.scheduleOrderNumber);
}
} else {
if (KEY.TRAINS == key && this.trainNumber == index) {
this.display(this.trainNumber);
}
}
}
public void itemAdded(KEY key, int index, FreerailsPrincipal p) {
}
public void itemRemoved(KEY key, int index, FreerailsPrincipal p) {
}
}

/**
* JPanel that displays a list of trains, used for the train list window and the
* train roster tab.
*
* @author Luke
*/
public class TrainListJPanel extends javax.swing.JPanel implements View, ModelRootListener {
private static final long serialVersionUID = 3832905463863064626L;
private ReadOnlyWorld world;
private FreerailsPrincipal principal;
private int lastNumberOfTrains = -1;
private boolean rhsjTabPane = false; // if the train list is for the
// rhsjTabPane then use the original
// renderer, if not use the
// trainsummaryjpanel
/** Creates new form TrainListJPanel. */
public TrainListJPanel() {
initComponents();
}
public TrainListJPanel(boolean isInRHSJTabPane) {
this();
rhsjTabPane = isInRHSJTabPane;
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
private void initComponents() {// GEN-BEGIN:initComponents
java.awt.GridBagConstraints gridBagConstraints;
trainSummaryJPanel1 = new jfreerails.client.view.TrainSummaryJPanel();
closeJButton = new javax.swing.JButton();
showDetails = new javax.swing.JButton();
jScrollPane1 = new javax.swing.JScrollPane();
jList1 = new javax.swing.JList();
trainNumLabel = new javax.swing.JLabel();
trainHeadingLabel = new javax.swing.JLabel();
maintenanceLabel = new javax.swing.JLabel();
incomeLabel = new javax.swing.JLabel();
setLayout(new java.awt.GridBagLayout());
setPreferredSize(new java.awt.Dimension(510, 300));
closeJButton.setText("Close");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 2;
gridBagConstraints.gridwidth = 2;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.insets = new java.awt.Insets(7, 7, 7, 7);
add(closeJButton, gridBagConstraints);
showDetails.setText("Show details");
showDetails.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
showDetailsActionPerformed(evt);
}
});
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 2;
gridBagConstraints.gridy = 2;
gridBagConstraints.gridwidth = 2;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.insets = new java.awt.Insets(7, 7, 7, 7);
add(showDetails, gridBagConstraints);
jList1
.setSelectionMode(javax.swing.ListSelectionModel.SINGLE_SELECTION);
jList1.setCellRenderer(trainSummaryJPanel1);
jList1.setDoubleBuffered(true);
jList1.addKeyListener(new java.awt.event.KeyAdapter() {
@Override
public void keyPressed(java.awt.event.KeyEvent evt) {
jList1KeyPressed(evt);
}
});
jList1
.addListSelectionListener(new javax.swing.event.ListSelectionListener() {
public void valueChanged(
javax.swing.event.ListSelectionEvent evt) {
jList1ValueChanged(evt);
}
});
jList1.addMouseListener(new java.awt.event.MouseAdapter() {
@Override
public void mouseClicked(java.awt.event.MouseEvent evt) {
jList1MouseClicked(evt);
}
});
jScrollPane1.setViewportView(jList1);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.gridwidth = 4;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
add(jScrollPane1, gridBagConstraints);
trainNumLabel.setText("Train Number");
trainNumLabel.setMaximumSize(new java.awt.Dimension(500, 500));
trainNumLabel.setPreferredSize(new java.awt.Dimension(100, 14));
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 0;
gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
gridBagConstraints.insets = new java.awt.Insets(0, 0, 0, 5);
add(trainNumLabel, gridBagConstraints);
trainHeadingLabel.setText("Headed For");
trainHeadingLabel.setPreferredSize(new java.awt.Dimension(100, 14));
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 1;
gridBagConstraints.gridy = 0;
gridBagConstraints.insets = new java.awt.Insets(0, 5, 0, 5);
add(trainHeadingLabel, gridBagConstraints);
maintenanceLabel.setText("Maintenance YTD");
maintenanceLabel.setPreferredSize(new java.awt.Dimension(100, 14));
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 2;
gridBagConstraints.gridy = 0;
gridBagConstraints.insets = new java.awt.Insets(0, 5, 0, 5);
add(maintenanceLabel, gridBagConstraints);
incomeLabel.setText("Income YTD");
incomeLabel.setPreferredSize(new java.awt.Dimension(100, 14));
add(incomeLabel, new java.awt.GridBagConstraints());
}// GEN-END:initComponents
private void jList1ValueChanged(javax.swing.event.ListSelectionEvent evt) {// GEN-FIRST:event_jList1ValueChanged
// if a train is selected, enable the 'show details' button.
if (jList1.getSelectedIndex() != -1) {
this.showDetails.setEnabled(true);
} else {
this.showDetails.setEnabled(false);
}
}// GEN-LAST:event_jList1ValueChanged
private void showDetailsActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_showDetailsActionPerformed
showTrainDetails.actionPerformed(evt);
}// GEN-LAST:event_showDetailsActionPerformed
private void jList1MouseClicked(java.awt.event.MouseEvent evt) {// GEN-FIRST:event_jList1MouseClicked
// Add your handling code here:
if (evt.getClickCount() == 2) {
showTrainDetails.actionPerformed(null);
}
}// GEN-LAST:event_jList1MouseClicked
private void jList1KeyPressed(java.awt.event.KeyEvent evt) {// GEN-FIRST:event_jList1KeyPressed
// Add your handling code here:
if (evt.getKeyCode() == KeyEvent.VK_ENTER) {
showTrainDetails.actionPerformed(null);
}
}// GEN-LAST:event_jList1KeyPressed
public void setup(final ModelRoot mr, RenderersRoot vl,
Action closeAction) {
world = mr.getWorld();
trainSummaryJPanel1.setup(mr, vl, null);
if (rhsjTabPane) {
jList1.setModel(new World2ListModelAdapter(mr.getWorld(),
KEY.TRAINS, mr.getPrincipal()));
TrainListCellRenderer trainView = new TrainListCellRenderer(mr, vl);
jList1.setCellRenderer(trainView);
trainView.setHeight(trainViewHeight);
}
ActionListener[] oldListeners = closeJButton.getActionListeners();
for (int i = 0; i < oldListeners.length; i++) {
closeJButton.removeActionListener(oldListeners[i]);
}
closeJButton.addActionListener(closeAction);
ListSelectionListener[] old = jList1.getListSelectionListeners();
for(ListSelectionListener x : old){
jList1.removeListSelectionListener(x);
}
jList1.addListSelectionListener(new ListSelectionListener() {
@Override
public void valueChanged(ListSelectionEvent e) {
int id = getSelectedTrainID();
mr.setProperty(ModelRoot.Property.SELECTED_TRAIN, id);
}
});
principal = mr.getPrincipal();
ModelRootImpl mri = (ModelRootImpl) mr;
mri.addPropertyChangeListener(this);
}
void setShowTrainDetailsActionListener(ActionListener l) {
showTrainDetails = l;
}
private ActionListener showTrainDetails = new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
}
};
int getSelectedTrainID() {
/*
* Note, the selected index is not the train id since trains that have
* been removed are not shown on the list.
*/
int row = jList1.getSelectedIndex();
if (row == -1) {
return -1;
} else {
return NonNullElements.row2index(world, KEY.TRAINS, principal, row);
}
}
/** When the train list is shown on a tab we don't want the buttons. */
void removeButtons() {
this.removeAll();
java.awt.GridBagConstraints gridBagConstraints;
setLayout(new java.awt.GridBagLayout());
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
add(jScrollPane1, gridBagConstraints);
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JButton closeJButton;
private javax.swing.JLabel incomeLabel;
private javax.swing.JList jList1;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JLabel maintenanceLabel;
private javax.swing.JButton showDetails;
private javax.swing.JLabel trainHeadingLabel;
private javax.swing.JLabel trainNumLabel;
private jfreerails.client.view.TrainSummaryJPanel trainSummaryJPanel1;
// End of variables declaration//GEN-END:variables
private int trainViewHeight = 50;
@Override
public void setVisible(boolean aFlag) {
if (aFlag && null != world) {
// jList1.setModel(new World2ListModelAdapter(world,
// KEY.TRAINS,principal));
}
super.setVisible(aFlag);
}
public void setTrainViewHeight(int trainViewHeight) {
this.trainViewHeight = trainViewHeight;
}
@Override
public void paint(Graphics g) {
if (null != world) {
NonNullElements trains = new NonNullElements(KEY.TRAINS, world,
principal);
int newNumberOfTrains = trains.size();
if (newNumberOfTrains != this.lastNumberOfTrains) {
jList1.setModel(new World2ListModelAdapter(world, KEY.TRAINS,
principal));
if (newNumberOfTrains > 0) {
jList1.setSelectedIndex(0);
}
lastNumberOfTrains = newNumberOfTrains;
}
}
super.paint(g);
}
@Override
public void propertyChange(ModelRoot.Property p, Object oldValue, Object newValue) {
if(ModelRoot.Property.SELECTED_TRAIN == p){
if(!newValue.equals(this.getSelectedTrainID())){
//update needed..
TrainModel train = (TrainModel) world.get(principal, KEY.TRAINS, (int) newValue);
this.jList1.setSelectedValue(train, true);
}
}
}
}

/**
* ListCellRenderer that displays a train order.
*
* @author Luke Lindsay
*/
public class TrainOrderJPanel extends javax.swing.JPanel implements View,
ListCellRenderer {
private static final long serialVersionUID = 4051047466990319413L;
private jfreerails.world.top.ReadOnlyWorld w;
private FreerailsPrincipal principal;
private final ImageIcon gotoNow = new ImageIcon(TrainOrderJPanel.class
.getResource("/jfreerails/client/graphics/selected_arrow.png"));
private final ImageIcon gotoAfterPriorityOrders = new ImageIcon(
TrainOrderJPanel.class
.getResource("/jfreerails/client/graphics/deselected_arrow.png"));
private final ImageIcon dontGoto = null;
private final Color backgroundColor = (java.awt.Color) javax.swing.UIManager
.getDefaults().get("List.background");
private final Color selectedColor = (java.awt.Color) javax.swing.UIManager
.getDefaults().get("List.selectionBackground");
private final Color selectedColorNotFocused = Color.LIGHT_GRAY;
public TrainOrderJPanel() {
initComponents();
this.setBackground(backgroundColor);
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
private void initComponents() {// GEN-BEGIN:initComponents
java.awt.GridBagConstraints gridBagConstraints;
gotoIcon = new javax.swing.JLabel();
consistChangeJPanel = new TrainListCellRenderer();
noChangeJLabel = new javax.swing.JLabel();
stationNameJLabel = new javax.swing.JLabel();
ordersJLabel = new javax.swing.JLabel();
setLayout(new java.awt.GridBagLayout());
gotoIcon.setIcon(new javax.swing.ImageIcon(getClass().getResource(
"/jfreerails/client/graphics/selected_arrow.png")));
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 0;
gridBagConstraints.gridheight = 2;
gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
add(gotoIcon, gridBagConstraints);
consistChangeJPanel.setLayout(new java.awt.GridBagLayout());
noChangeJLabel.setText("No Change");
consistChangeJPanel.add(noChangeJLabel,
new java.awt.GridBagConstraints());
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 1;
gridBagConstraints.gridy = 1;
gridBagConstraints.gridwidth = 2;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
gridBagConstraints.weightx = 1.0;
add(consistChangeJPanel, gridBagConstraints);
stationNameJLabel.setText("Some Station");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 1;
gridBagConstraints.gridy = 0;
gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
gridBagConstraints.insets = new java.awt.Insets(0, 5, 0, 5);
add(stationNameJLabel, gridBagConstraints);
ordersJLabel.setText("wait until full / don't wait");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 2;
gridBagConstraints.gridy = 0;
gridBagConstraints.ipadx = 6;
gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
gridBagConstraints.insets = new java.awt.Insets(0, 6, 0, 5);
add(ordersJLabel, gridBagConstraints);
}// GEN-END:initComponents
public void setup(ModelRoot mr, RenderersRoot vl,
Action closeAction) {
this.w = mr.getWorld();
TrainListCellRenderer trainViewJPanel = (TrainListCellRenderer) consistChangeJPanel;
trainViewJPanel.setHeight(15);
trainViewJPanel.setup(mr, vl, null);
this.principal = mr.getPrincipal();
}
public java.awt.Component getListCellRendererComponent(JList list,
Object value, int index, boolean isSelected, boolean cellHasFocus) {
TrainOrdersListModel.TrainOrdersListElement trainOrders = (TrainOrdersListModel.TrainOrdersListElement) value;
// Set station name
int stationNumber = trainOrders.order.stationId;
StationModel station = (StationModel) w.get(principal,
KEY.STATIONS, stationNumber);
String stationName = station.getStationName();
this.stationNameJLabel.setText(stationName);
// Set wait until full
String waitUntilFull = trainOrders.order.waitUntilFull ? "Wait until full"
: "";
this.ordersJLabel.setText(waitUntilFull);
// Set selected
if (isSelected) {
if (list.isFocusOwner()) {
setBackground(selectedColor);
} else {
setBackground(selectedColorNotFocused);
}
} else {
setBackground(backgroundColor);
}
// Set goto status.
switch (trainOrders.gotoStatus) {
case TrainOrdersListModel.DONT_GOTO:
this.gotoIcon.setIcon(this.dontGoto);
break;
case TrainOrdersListModel.GOTO_AFTER_PRIORITY_ORDERS:
this.gotoIcon.setIcon(this.gotoAfterPriorityOrders);
break;
case TrainOrdersListModel.GOTO_NOW:
this.gotoIcon.setIcon(this.gotoNow);
break;
default:
throw new IllegalArgumentException(String
.valueOf(trainOrders.gotoStatus));
}
this.gotoIcon.setPreferredSize(new Dimension(20, 20));
// Set consist
TrainListCellRenderer trainViewJPanel = (TrainListCellRenderer) consistChangeJPanel;
trainViewJPanel.display(trainOrders.trainNumber, index);
// Show priority orders.
if (trainOrders.isPriorityOrder) {
// Write the station name in upper case
String s = this.stationNameJLabel.getText();
this.stationNameJLabel.setText(s + " (Priority Orders)");
}
// Check for 'No change'
if (null == trainOrders.order.consist) {
if (trainOrders.order.autoConsist) {
this.noChangeJLabel.setText("Select wagons automatically");
} else {
this.noChangeJLabel.setText("No Change");
}
} else {
this.noChangeJLabel.setText(null);
}
// Set the section title
// this.sectionTitleJLabel.setText("trainOrders.sectionTitle");
return this;
}
// Variables declaration - do not modify//GEN-BEGIN:variables
javax.swing.JPanel consistChangeJPanel;
javax.swing.JLabel gotoIcon;
javax.swing.JLabel noChangeJLabel;
javax.swing.JLabel ordersJLabel;
javax.swing.JLabel stationNameJLabel;
// End of variables declaration//GEN-END:variables
}

/**
* AbstractListModel used by {@link TrainScheduleJPanel} to display the orders
* making up a train schedule.
*
* @author Luke Lindsay
*/
public class TrainOrdersListModel extends AbstractListModel {
private static final long serialVersionUID = 3762537827703009847L;
private final int trainNumber;
private final ReadOnlyWorld w;
private final FreerailsPrincipal principal;
public static final int DONT_GOTO = 0;
public static final int GOTO_NOW = 1;
public static final int GOTO_AFTER_PRIORITY_ORDERS = 2;
/**
* This class holds the values that are needed by the ListCellRender.
* TrainOrdersListModel.getElementAt(int index) returns an instance of this
* class.
*/
public static class TrainOrdersListElement {
public final boolean isPriorityOrder;
public final int gotoStatus;
public final TrainOrdersModel order;
public final int trainNumber;
public TrainOrdersListElement(boolean isPriorityOrder, int gotoStatus,
TrainOrdersModel order, int trainNumber) {
this.isPriorityOrder = isPriorityOrder;
this.gotoStatus = gotoStatus;
this.order = order;
this.trainNumber = trainNumber;
}
}
public TrainOrdersListModel(ReadOnlyWorld w, int trainNumber,
FreerailsPrincipal p) {
this.trainNumber = trainNumber;
this.w = w;
this.principal = p;
assert (null != getSchedule());
}
public Object getElementAt(int index) {
Schedule s = getSchedule();
int gotoStatus;
if (s.getNextScheduledOrder() == index) {
if (s.hasPriorityOrders()) {
gotoStatus = GOTO_AFTER_PRIORITY_ORDERS;
} else {
gotoStatus = GOTO_NOW;
}
} else {
if (s.hasPriorityOrders() && 0 == index) {
// These orders are the priority orders.
gotoStatus = GOTO_NOW;
} else {
gotoStatus = DONT_GOTO;
}
}
boolean isPriorityOrders = 0 == index && s.hasPriorityOrders();
TrainOrdersModel order = getSchedule().getOrder(index);
return new TrainOrdersListElement(isPriorityOrders, gotoStatus, order,
trainNumber);
}
public int getSize() {
Schedule s = getSchedule();
int size = 0;
if (s != null) {
size = s.getNumOrders();
}
return size;
}
public void fireRefresh() {
super.fireContentsChanged(this, 0, getSize());
}
private Schedule getSchedule() {
TrainModel train = (TrainModel) w.get(principal, KEY.TRAINS,
trainNumber);
ImmutableSchedule sched = null;
if (train != null) {
sched = (ImmutableSchedule) w.get(principal, KEY.TRAIN_SCHEDULES, train
.getScheduleID());
}
return sched;
}
}

/**
* This JPanel displays a train's schedule and provides controls that let you
* edit it.
*
* @author Luke Lindsay
*/
public class TrainScheduleJPanel extends javax.swing.JPanel implements View,
WorldListListener {
private static final long serialVersionUID = 3762248626113884214L;
private static final Logger logger = Logger
.getLogger(TrainScheduleJPanel.class.getName());
private int trainNumber = -1;
private int scheduleID = -1;
private TrainOrdersListModel listModel;
private ModelRoot modelRoot;
private RenderersRoot vl;
public TrainScheduleJPanel() {
initComponents();
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
private void initComponents() {// GEN-BEGIN:initComponents
java.awt.GridBagConstraints gridBagConstraints;
trainOrderJPanel1 = new jfreerails.client.view.TrainOrderJPanel();
editOrderJPopupMenu = new javax.swing.JPopupMenu();
gotoStationJMenuItem = new javax.swing.JMenuItem();
changeStation = new javax.swing.JMenuItem();
removeStationJMenuItem = new javax.swing.JMenuItem();
jSeparator1 = new javax.swing.JSeparator();
addWagonJMenu = new javax.swing.JMenu();
removeWagonsJMenu = new javax.swing.JMenu();
removeLastJMenuItem = new javax.swing.JMenuItem();
removeAllJMenuItem = new javax.swing.JMenuItem();
changeConsistJMenu = new javax.swing.JMenu();
noChangeJMenuItem = new javax.swing.JMenuItem();
engineOnlyJMenuItem = new javax.swing.JMenuItem();
autoConsistJMenuItem = new javax.swing.JMenuItem();
waitJMenu = new javax.swing.JMenu();
dontWaitJMenuItem = new javax.swing.JMenuItem();
waitUntilFullJMenuItem = new javax.swing.JMenuItem();
jSeparator2 = new javax.swing.JSeparator();
pullUpJMenuItem = new javax.swing.JMenuItem();
pushDownJMenuItem = new javax.swing.JMenuItem();
selectStationJPanel1 = new jfreerails.client.view.SelectStationJPanel();
selectStationJPopupMenu = new javax.swing.JPopupMenu();
this.selectStationJPopupMenu.add(selectStationJPanel1);
addStationJButton = new javax.swing.JButton();
priorityOrdersJButton = new javax.swing.JButton();
jScrollPane1 = new javax.swing.JScrollPane();
orders = new javax.swing.JList();
gotoStationJMenuItem.setText("Goto station");
gotoStationJMenuItem
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
gotoStationJMenuItemActionPerformed(evt);
}
});
editOrderJPopupMenu.add(gotoStationJMenuItem);
changeStation.setText("Change Station");
changeStation.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
changeStationActionPerformed(evt);
}
});
editOrderJPopupMenu.add(changeStation);
removeStationJMenuItem.setText("Remove station");
removeStationJMenuItem
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
removeStationJMenuItemActionPerformed(evt);
}
});
editOrderJPopupMenu.add(removeStationJMenuItem);
editOrderJPopupMenu.add(jSeparator1);
addWagonJMenu.setText("Add Wagon");
editOrderJPopupMenu.add(addWagonJMenu);
removeWagonsJMenu.setText("Remove wagon(s)");
removeLastJMenuItem.setText("Remove last");
removeLastJMenuItem
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
removeLastJMenuItemActionPerformed(evt);
}
});
removeWagonsJMenu.add(removeLastJMenuItem);
removeAllJMenuItem.setText("Remove all wagons");
removeAllJMenuItem
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
removeAllJMenuItemActionPerformed(evt);
}
});
removeWagonsJMenu.add(removeAllJMenuItem);
editOrderJPopupMenu.add(removeWagonsJMenu);
changeConsistJMenu.setText("Change consist to..");
noChangeJMenuItem.setText("'No change'");
noChangeJMenuItem
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
noChangeJMenuItemActionPerformed(evt);
}
});
changeConsistJMenu.add(noChangeJMenuItem);
engineOnlyJMenuItem.setText("Engine only");
engineOnlyJMenuItem
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
engineOnlyJMenuItemActionPerformed(evt);
}
});
changeConsistJMenu.add(engineOnlyJMenuItem);
autoConsistJMenuItem.setText("Choose wagons automatically");
autoConsistJMenuItem
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
autoConsistJMenuItemActionPerformed(evt);
}
});
changeConsistJMenu.add(autoConsistJMenuItem);
editOrderJPopupMenu.add(changeConsistJMenu);
waitJMenu.setText("Wait at station");
dontWaitJMenuItem.setText("Don't wait");
dontWaitJMenuItem
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
dontWaitJMenuItemActionPerformed(evt);
}
});
waitJMenu.add(dontWaitJMenuItem);
waitUntilFullJMenuItem.setText("Wait until full");
waitUntilFullJMenuItem
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
waitUntilFullJMenuItemActionPerformed(evt);
}
});
waitJMenu.add(waitUntilFullJMenuItem);
editOrderJPopupMenu.add(waitJMenu);
editOrderJPopupMenu.add(jSeparator2);
pullUpJMenuItem.setText("Pull up");
pullUpJMenuItem.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
pullUpJMenuItemActionPerformed(evt);
}
});
editOrderJPopupMenu.add(pullUpJMenuItem);
pushDownJMenuItem.setText("Push down");
pushDownJMenuItem
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
pushDownJMenuItemActionPerformed(evt);
}
});
editOrderJPopupMenu.add(pushDownJMenuItem);
setLayout(new java.awt.GridBagLayout());
setBorder(new javax.swing.border.TitledBorder("Schedule"));
addStationJButton.setText("Add Station");
addStationJButton
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
addStationJButtonActionPerformed(evt);
}
});
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.insets = new java.awt.Insets(7, 7, 7, 7);
add(addStationJButton, gridBagConstraints);
priorityOrdersJButton.setText("Add Priority Orders");
priorityOrdersJButton
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
priorityOrdersJButtonActionPerformed(evt);
}
});
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 1;
gridBagConstraints.gridy = 1;
gridBagConstraints.insets = new java.awt.Insets(7, 7, 7, 7);
add(priorityOrdersJButton, gridBagConstraints);
jScrollPane1.setPreferredSize(new java.awt.Dimension(280, 160));
orders
.setSelectionMode(javax.swing.ListSelectionModel.SINGLE_SELECTION);
orders.setCellRenderer(trainOrderJPanel1);
orders.addKeyListener(new java.awt.event.KeyAdapter() {
@Override
public void keyPressed(java.awt.event.KeyEvent evt) {
ordersKeyPressed(evt);
}
});
orders.addMouseListener(new java.awt.event.MouseAdapter() {
@Override
public void mouseClicked(java.awt.event.MouseEvent evt) {
ordersMouseClicked(evt);
}
});
jScrollPane1.setViewportView(orders);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 0;
gridBagConstraints.gridwidth = 2;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weighty = 1.0;
gridBagConstraints.insets = new java.awt.Insets(3, 3, 3, 3);
add(jScrollPane1, gridBagConstraints);
}// GEN-END:initComponents
private void ordersKeyPressed(java.awt.event.KeyEvent evt) {// GEN-FIRST:event_ordersKeyPressed
switch (evt.getKeyCode()) {
case KeyEvent.VK_O: {
// Add priority orders
priorityOrdersJButtonActionPerformed(null);
break;
}
case KeyEvent.VK_N: {
// Add station
addStationJButtonActionPerformed(null);
break;
}
default: {
// do nothing.
}
}
int orderNumber = this.orders.getSelectedIndex();
if (orderNumber == -1) {
// No order is selected.
return;
}
switch (evt.getKeyCode()) {
case KeyEvent.VK_G: {
// Goto station.
gotoStationJMenuItemActionPerformed(null);
break;
}
case KeyEvent.VK_S: {
// Change station
showSelectStation(this.getSchedule(), orderNumber);
break;
}
case KeyEvent.VK_A: {
// Auto schedule
setAutoConsist();
break;
}
case KeyEvent.VK_C: {
// Change add wagon
break;
}
case KeyEvent.VK_DELETE: {
// Remove station
removeStationJMenuItemActionPerformed(null);
break;
}
case KeyEvent.VK_BACK_SPACE: {
// Remove last wagon
removeLastWagon();
break;
}
case KeyEvent.VK_W: {
// toggle wait until full
MutableSchedule s = getSchedule();
TrainOrdersModel order = s.getOrder(orderNumber);
setWaitUntilFull(!order.waitUntilFull);
break;
}
default: {
// do nothing.
}
}
listModel.fireRefresh();
}// GEN-LAST:event_ordersKeyPressed
private void autoConsistJMenuItemActionPerformed(
java.awt.event.ActionEvent evt) {// GEN-FIRST:event_autoConsistJMenuItemActionPerformed
setAutoConsist();
}// GEN-LAST:event_autoConsistJMenuItemActionPerformed
private void changeStationActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_changeStationActionPerformed
int orderNumber = this.orders.getSelectedIndex();
showSelectStation(this.getSchedule(), orderNumber);
}// GEN-LAST:event_changeStationActionPerformed
private void removeAllJMenuItemActionPerformed(
java.awt.event.ActionEvent evt) {// GEN-FIRST:event_removeAllJMenuItemActionPerformed
removeAllWagons();
}// GEN-LAST:event_removeAllJMenuItemActionPerformed
private void removeLastJMenuItemActionPerformed(
java.awt.event.ActionEvent evt) {// GEN-FIRST:event_removeLastJMenuItemActionPerformed
removeLastWagon();
}// GEN-LAST:event_removeLastJMenuItemActionPerformed
private void waitUntilFullJMenuItemActionPerformed(
java.awt.event.ActionEvent evt) {// GEN-FIRST:event_waitUntilFullJMenuItemActionPerformed
setWaitUntilFull(true);
}// GEN-LAST:event_waitUntilFullJMenuItemActionPerformed
private void dontWaitJMenuItemActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_dontWaitJMenuItemActionPerformed
setWaitUntilFull(false);
}// GEN-LAST:event_dontWaitJMenuItemActionPerformed
private void engineOnlyJMenuItemActionPerformed(
java.awt.event.ActionEvent evt) {// GEN-FIRST:event_engineOnlyJMenuItemActionPerformed
removeAllWagons();
}// GEN-LAST:event_engineOnlyJMenuItemActionPerformed
private void noChangeJMenuItemActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_noChangeJMenuItemActionPerformed
noChange();
}// GEN-LAST:event_noChangeJMenuItemActionPerformed
private void priorityOrdersJButtonActionPerformed(
java.awt.event.ActionEvent evt) {// GEN-FIRST:event_priorityOrdersJButtonActionPerformed
MutableSchedule s = getSchedule();
try {
s.setPriorityOrders(new TrainOrdersModel(getFirstStationID(), null,
false, false));// TODO fix bug
showSelectStation(s, Schedule.PRIORITY_ORDERS);
} catch (NoSuchElementException e) {
logger
.warning("No stations exist so can't add station to schedule!");
}
}// GEN-LAST:event_priorityOrdersJButtonActionPerformed
private void addStationJButtonActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_addStationJButtonActionPerformed
MutableSchedule s = getSchedule();
try {
int newOrderNumber = s.addOrder(new TrainOrdersModel(
getFirstStationID(), null, false, false)); // TODO fix bug
showSelectStation(s, newOrderNumber);
} catch (NoSuchElementException e) {
logger
.warning("No stations exist so can't add station to schedule!");
}
}// GEN-LAST:event_addStationJButtonActionPerformed
private void removeStationJMenuItemActionPerformed(
java.awt.event.ActionEvent evt) {// GEN-FIRST:event_removeStationJMenuItemActionPerformed
MutableSchedule s = getSchedule();
if(s.getNumOrders() ==0){
logger.warning("Can't remove orders since non exist!");
return;
}
int i = orders.getSelectedIndex();
if(s.getNumOrders() <= i){
logger.warning("Order #"+String.valueOf(i)+" does not exist!");
return;
}
s.removeOrder(i);
sendUpdateMove(s);
}// GEN-LAST:event_removeStationJMenuItemActionPerformed
private void gotoStationJMenuItemActionPerformed(
java.awt.event.ActionEvent evt) {// GEN-FIRST:event_gotoStationJMenuItemActionPerformed
MutableSchedule s = getSchedule();
int i = orders.getSelectedIndex();
s.setOrderToGoto(i);
sendUpdateMove(s);
}// GEN-LAST:event_gotoStationJMenuItemActionPerformed
private void pushDownJMenuItemActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_pushDownJMenuItemActionPerformed
MutableSchedule s = getSchedule();
int i = orders.getSelectedIndex();
s.pushDown(i);
sendUpdateMove(s);
orders.setSelectedIndex(i + 1);
}// GEN-LAST:event_pushDownJMenuItemActionPerformed
private void ordersMouseClicked(java.awt.event.MouseEvent evt) {// GEN-FIRST:event_ordersMouseClicked
int i = orders.getSelectedIndex();
MutableSchedule s = getSchedule();
if (i >= s.getNumOrders()) {
// The selected index does not exist!
// For some reason, the JList hasn't updated yet.
i = -1;
}
if (-1 != i && java.awt.event.MouseEvent.BUTTON3 == evt.getButton()) {
// If an element is select and the right button is pressed.
TrainOrdersModel order = s.getOrder(i);
pullUpJMenuItem.setEnabled(s.canPullUp(i));
pushDownJMenuItem.setEnabled(s.canPushDown(i));
gotoStationJMenuItem.setEnabled(s.canSetGotoStation(i));
removeWagonsJMenu.setEnabled(order.orderHasWagons());
waitJMenu.setEnabled(order.orderHasWagons());
addWagonJMenu.setEnabled(order.hasLessThanMaximumNumberOfWagons());
setupWagonsPopup();
this.editOrderJPopupMenu.show(evt.getComponent(), evt.getX(), evt
.getY());
}
}// GEN-LAST:event_ordersMouseClicked
private void pullUpJMenuItemActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_pullUpJMenuItemActionPerformed
MutableSchedule s = getSchedule();
int i = orders.getSelectedIndex();
s.pullUp(i);
sendUpdateMove(s);
orders.setSelectedIndex(i - 1);
}// GEN-LAST:event_pullUpJMenuItemActionPerformed
public void setup(ModelRoot mr, RenderersRoot vl, Action al) {
trainOrderJPanel1.setup(mr, vl, null);
this.modelRoot = mr;
this.vl = vl;
// This actionListener is fired by the select station popup when a
// station is selected.
Action action = new AbstractAction() {
private static final long serialVersionUID = 1L;
public void actionPerformed(ActionEvent evt) {
sendUpdateMove(selectStationJPanel1.generateNewSchedule());
selectStationJPopupMenu.setVisible(false);
listModel.fireRefresh();
orders.requestFocus();
}
};
this.selectStationJPanel1.setup(mr, vl, action);
}
public void display(int newTrainNumber) {
this.trainNumber = newTrainNumber;
FreerailsPrincipal principal = modelRoot.getPrincipal();
ReadOnlyWorld w = modelRoot.getWorld();
TrainModel train = (TrainModel) w.get(principal, KEY.TRAINS,
newTrainNumber);
this.scheduleID = train.getScheduleID();
listModel = new TrainOrdersListModel(w, newTrainNumber, principal);
orders.setModel(listModel);
orders.setFixedCellWidth(250);
listModel.fireRefresh();
enableButtons();
}
private void enableButtons() {
MutableSchedule s = getSchedule();
addStationJButton.setEnabled(s.canAddOrder());
// Only one set of priority orders are allowed.
priorityOrdersJButton.setEnabled(!s.hasPriorityOrders());
}
private MutableSchedule getSchedule() {
FreerailsPrincipal principal = modelRoot.getPrincipal();
ReadOnlyWorld w = modelRoot.getWorld();
TrainModel train = (TrainModel) w.get(principal, KEY.TRAINS,
trainNumber);
ImmutableSchedule immutableSchedule = (ImmutableSchedule) w.get(
principal, KEY.TRAIN_SCHEDULES, train.getScheduleID());
return new MutableSchedule(immutableSchedule);
}
/**
* Since stations can be removed, we should not assume that station 0
* exists: this method returns the id of the first station that exists.
*
*/
private int getFirstStationID() {
NonNullElements stations = new NonNullElements(KEY.STATIONS, modelRoot
.getWorld(), modelRoot.getPrincipal());
if (stations.next()) {
return stations.getIndex();
}
throw new NoSuchElementException();
}
private void setupWagonsPopup() {
addWagonJMenu.removeAll(); // Remove existing menu items.
NonNullElements cargoTypes = new NonNullElements(SKEY.CARGO_TYPES,
modelRoot.getWorld());
while (cargoTypes.next()) {
final CargoType wagonType = (CargoType) cargoTypes.getElement();
JMenuItem wagonMenuItem = new JMenuItem();
final int wagonTypeNumber = cargoTypes.getIndex();
wagonMenuItem.setText(wagonType.getDisplayName());
Image image = vl.getWagonImages(wagonTypeNumber).getSideOnImage();
int height = image.getHeight(null);
int width = image.getWidth(null);
int scale = height / 10;
ImageIcon icon = new ImageIcon(image.getScaledInstance(width
/ scale, height / scale, Image.SCALE_FAST));
wagonMenuItem.setIcon(icon);
wagonMenuItem
.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(
java.awt.event.ActionEvent evt) {
addWagon(wagonTypeNumber);
}
});
addWagonJMenu.add(wagonMenuItem);
}
}
private void noChange() {
TrainOrdersModel oldOrders, newOrders;
MutableSchedule s = getSchedule();
int orderNumber = this.orders.getSelectedIndex();
oldOrders = s.getOrder(orderNumber);
newOrders = new TrainOrdersModel(oldOrders.getStationID(), null, false,
false);
s.setOrder(orderNumber, newOrders);
sendUpdateMove(s);
}
private void setWaitUntilFull(boolean b) {
TrainOrdersModel oldOrders, newOrders;
MutableSchedule s = getSchedule();
int orderNumber = this.orders.getSelectedIndex();
oldOrders = s.getOrder(orderNumber);
// If auto-consist is set do nothing
if (oldOrders.autoConsist)
return;
// If no-change is set do nothing
if (oldOrders.consist == null)
return;
boolean autoConsist = false;
newOrders = new TrainOrdersModel(oldOrders.getStationID(),
oldOrders.consist, b, autoConsist);
s.setOrder(orderNumber, newOrders);
sendUpdateMove(s);
}
private void setAutoConsist() {
TrainOrdersModel oldOrders, newOrders;
MutableSchedule s = getSchedule();
int orderNumber = this.orders.getSelectedIndex();
oldOrders = s.getOrder(orderNumber);
newOrders = new TrainOrdersModel(oldOrders.getStationID(), null, false,
true);
s.setOrder(orderNumber, newOrders);
sendUpdateMove(s);
}
private void addWagon(int wagonTypeNumber) {
TrainOrdersModel oldOrders, newOrders;
MutableSchedule s = getSchedule();
int orderNumber = this.orders.getSelectedIndex();
oldOrders = s.getOrder(orderNumber);
int[] newConsist;
// The consist will be null if old orders were 'no change'.
if (null != oldOrders.consist) {
int oldLength = oldOrders.consist.size();
newConsist = new int[oldLength + 1];
// Copy existing wagons
for (int i = 0; i < oldLength; i++) {
newConsist[i] = oldOrders.consist.get(i);
}
// Then add specified wagon.
newConsist[oldLength] = wagonTypeNumber;
} else {
newConsist = new int[] { wagonTypeNumber };
}
newOrders = new TrainOrdersModel(oldOrders.getStationID(), new ImInts(
newConsist), oldOrders.getWaitUntilFull(), false);
s.setOrder(orderNumber, newOrders);
sendUpdateMove(s);
}
private void removeAllWagons() {
TrainOrdersModel oldOrders, newOrders;
MutableSchedule s = getSchedule();
int orderNumber = this.orders.getSelectedIndex();
oldOrders = s.getOrder(orderNumber);
newOrders = new TrainOrdersModel(oldOrders.getStationID(),
new ImInts(), false, false);
s.setOrder(orderNumber, newOrders);
sendUpdateMove(s);
}
private void removeLastWagon() {
TrainOrdersModel oldOrders, newOrders;
MutableSchedule s = getSchedule();
int orderNumber = this.orders.getSelectedIndex();
oldOrders = s.getOrder(orderNumber);
ImInts oldConsist = oldOrders.consist;
if( null == oldConsist){
//consist can be null if there is no
//scheduled change of wagons.
//Fixes freerails bug 1687677 and freerails2 bug 2014234
return;
}
int newLength = oldConsist.size() - 1;
if (newLength < 0) {
//No wagons to remove!
return;
}
ImInts newConsist = oldConsist.removeLast();
newOrders = new TrainOrdersModel(oldOrders.getStationID(), newConsist,
oldOrders.waitUntilFull, false);
s.setOrder(orderNumber, newOrders);
sendUpdateMove(s);
}
private void sendUpdateMove(MutableSchedule mutableSchedule) {
FreerailsPrincipal principal = modelRoot.getPrincipal();
ReadOnlyWorld w = modelRoot.getWorld();
TrainModel train = (TrainModel) w.get(principal, KEY.TRAINS,
this.trainNumber);
// int scheduleID = train.getScheduleID();
assert (scheduleID == train.getScheduleID());
ImmutableSchedule before = (ImmutableSchedule) w.get(
principal, KEY.TRAIN_SCHEDULES, scheduleID);
ImmutableSchedule after = mutableSchedule.toImmutableSchedule();
Move m = new ChangeTrainScheduleMove(scheduleID, before, after,
principal);
this.modelRoot.doMove(m);
}
public void listUpdated(KEY key, int index, FreerailsPrincipal p) {
if (KEY.TRAIN_SCHEDULES == key && this.scheduleID == index) {
listModel.fireRefresh();
enableButtons();
}
}
public void itemAdded(KEY key, int index, FreerailsPrincipal p) {
// do nothing.
}
public void itemRemoved(KEY key, int index, FreerailsPrincipal p) {
// do nothing.
}
/**
* Show the popup that lets the user select a station, called when a new
* scheduled stop is added and when an existing scheduled stop is changed.
*/
private void showSelectStation(MutableSchedule schedule, int orderNumber) {
selectStationJPanel1.display(schedule, orderNumber);
// Show the select station popup in the middle of the window.
Container topLevelAncestor = this.getTopLevelAncestor();
Dimension d = topLevelAncestor.getSize();
Dimension d2 = selectStationJPopupMenu.getPreferredSize();
int x = Math.max((d.width - d2.width) / 2, 0);
int y = Math.max((d.height - d2.height) / 2, 0);
selectStationJPopupMenu.show(topLevelAncestor, x, y);
selectStationJPanel1.requestFocus();
}
// Variables declaration - do not modify//GEN-BEGIN:variables
javax.swing.JButton addStationJButton;
javax.swing.JMenu addWagonJMenu;
javax.swing.JMenuItem autoConsistJMenuItem;
javax.swing.JMenu changeConsistJMenu;
javax.swing.JMenuItem changeStation;
javax.swing.JMenuItem dontWaitJMenuItem;
javax.swing.JPopupMenu editOrderJPopupMenu;
javax.swing.JMenuItem engineOnlyJMenuItem;
javax.swing.JMenuItem gotoStationJMenuItem;
javax.swing.JScrollPane jScrollPane1;
javax.swing.JSeparator jSeparator1;
javax.swing.JSeparator jSeparator2;
javax.swing.JMenuItem noChangeJMenuItem;
javax.swing.JList orders;
javax.swing.JButton priorityOrdersJButton;
javax.swing.JMenuItem pullUpJMenuItem;
javax.swing.JMenuItem pushDownJMenuItem;
javax.swing.JMenuItem removeAllJMenuItem;
javax.swing.JMenuItem removeLastJMenuItem;
javax.swing.JMenuItem removeStationJMenuItem;
javax.swing.JMenu removeWagonsJMenu;
jfreerails.client.view.SelectStationJPanel selectStationJPanel1;
javax.swing.JPopupMenu selectStationJPopupMenu;
jfreerails.client.view.TrainOrderJPanel trainOrderJPanel1;
javax.swing.JMenu waitJMenu;
javax.swing.JMenuItem waitUntilFullJMenuItem;
// End of variables declaration//GEN-END:variables
}

/**
*
* @author cphillips
*/
public class TrainSummaryJPanel extends javax.swing.JPanel implements
ListCellRenderer, View {
private static final long serialVersionUID = 4121133628006020919L;
private jfreerails.world.top.ReadOnlyWorld w;
private FreerailsPrincipal principal;
private final Color backgroundColor = (java.awt.Color) javax.swing.UIManager
.getDefaults().get("List.background");
private final Color selectedColor = (java.awt.Color) javax.swing.UIManager
.getDefaults().get("List.selectionBackground");
private final Color selectedColorNotFocused = Color.LIGHT_GRAY;
private TrainListCellRenderer trainListCellRenderer1;
/** Creates new form TrainSummaryJPanel */
public TrainSummaryJPanel() {
initComponents();
}
public void setup(ModelRoot modelRoot, RenderersRoot vl,
Action closeAction) {
this.principal = modelRoot.getPrincipal();
this.w = modelRoot.getWorld();
trainListCellRenderer1 = new TrainListCellRenderer(modelRoot, vl);
trainListCellRenderer1.setHeight(15);
}
private String findStationName(int trainNum) {
TrainOrdersModel orders = null;
TrainOrdersListModel ordersList = new TrainOrdersListModel(w, trainNum,
principal);
for (int i = 0; i < ordersList.getSize(); ++i) {
TrainOrdersListElement element = (TrainOrdersListElement) ordersList
.getElementAt(i);
if (element.gotoStatus == TrainOrdersListModel.GOTO_NOW) {
orders = element.order;
break;
}
}
StationModel station = (StationModel) w.get(principal, KEY.STATIONS, orders
.getStationID());
return station.getStationName();
}
private String findTrainIncome(int trainNum) {
IncomeStatementGenerator income = new IncomeStatementGenerator(w,
principal);
Money m = income.calTrainRevenue(trainNum);
return "$" + m.toString();
}
public java.awt.Component getListCellRendererComponent(
javax.swing.JList list, Object value, int index,
boolean isSelected, boolean cellHasFocus) {
int trainID = NonNullElements
.row2index(w, KEY.TRAINS, principal, index);
trainNumLabel.setText("#" + (trainID + 1));
headingLabel.setText(findStationName(trainID));
trainMaintenanceCostLabel.setText(findMaintenanceCost());
trainIncomeLabel.setText(findTrainIncome(trainID));
java.awt.GridBagConstraints gridBagConstraints;
trainListCellRenderer1.setOpaque(true);
trainListCellRenderer1.setCenterTrain(false);
trainListCellRenderer1.display(trainID);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.gridwidth = 4;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
gridBagConstraints.insets = new java.awt.Insets(3, 0, 3, 0);
add(trainListCellRenderer1, gridBagConstraints);
if (isSelected) {
if (list.isFocusOwner()) {
setBackground(selectedColor);
trainListCellRenderer1.setBackground(selectedColor);
} else {
setBackground(selectedColorNotFocused);
trainListCellRenderer1.setBackground(selectedColorNotFocused);
}
} else {
setBackground(backgroundColor);
trainListCellRenderer1.setBackground(backgroundColor);
}
// Set selected
return this;
}
private String findMaintenanceCost() {
GameTime time = w.currentTime();
GameCalendar gameCalendar = (GameCalendar) w.get(ITEM.CALENDAR);
double month = gameCalendar.getMonth(time.getTicks());
long cost = (long) (month / 12 * 5000);
Money m = new Money(cost);
return "$" + m.toString();
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
private void initComponents() {// GEN-BEGIN:initComponents
java.awt.GridBagConstraints gridBagConstraints;
trainNumLabel = new javax.swing.JLabel();
headingLabel = new javax.swing.JLabel();
trainMaintenanceCostLabel = new javax.swing.JLabel();
trainIncomeLabel = new javax.swing.JLabel();
setLayout(new java.awt.GridBagLayout());
setPreferredSize(new java.awt.Dimension(500, 50));
trainNumLabel.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
trainNumLabel.setText("jLabel1");
trainNumLabel
.setHorizontalTextPosition(javax.swing.SwingConstants.LEFT);
trainNumLabel.setPreferredSize(new java.awt.Dimension(100, 25));
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 0;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
gridBagConstraints.insets = new java.awt.Insets(0, 0, 0, 10);
add(trainNumLabel, gridBagConstraints);
headingLabel.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
headingLabel.setText("jLabel2");
headingLabel
.setHorizontalTextPosition(javax.swing.SwingConstants.CENTER);
headingLabel.setPreferredSize(new java.awt.Dimension(100, 25));
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 1;
gridBagConstraints.gridy = 0;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
gridBagConstraints.insets = new java.awt.Insets(0, 10, 0, 10);
add(headingLabel, gridBagConstraints);
trainMaintenanceCostLabel
.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
trainMaintenanceCostLabel.setText("jLabel3");
trainMaintenanceCostLabel.setMaximumSize(getMaximumSize());
trainMaintenanceCostLabel.setPreferredSize(new java.awt.Dimension(100,
25));
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 2;
gridBagConstraints.gridy = 0;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHEAST;
gridBagConstraints.insets = new java.awt.Insets(0, 10, 0, 10);
add(trainMaintenanceCostLabel, gridBagConstraints);
trainIncomeLabel
.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
trainIncomeLabel.setText("jLabel1");
trainIncomeLabel.setPreferredSize(new java.awt.Dimension(100, 25));
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.insets = new java.awt.Insets(0, 10, 0, 0);
add(trainIncomeLabel, gridBagConstraints);
}// GEN-END:initComponents
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JLabel headingLabel;
private javax.swing.JLabel trainIncomeLabel;
private javax.swing.JLabel trainMaintenanceCostLabel;
private javax.swing.JLabel trainNumLabel;
// End of variables declaration//GEN-END:variables
}

/**
* Defines a standard method to initiate GUI components that need access to the
* ModelRoot.
*
* @author Luke
*
*/
public interface View {
void setup(ModelRoot modelRoot, RenderersRoot vl,
Action closeAction);
}

/**
* Converts the interface of a list on the world object to a ListModel interface
* that can be used by JLists. Currently, change notification is <b>not</b>
* implemented (null elements are skipped).
*
* @author Luke
*
*/
public class World2ListModelAdapter implements ListModel {
private final ReadOnlyWorld w;
private final NonNullElements elements;
public World2ListModelAdapter(ReadOnlyWorld world, SKEY key) {
this.w = world;
if (null == key)
throw new NullPointerException();
if (null == w)
throw new NullPointerException();
elements = new NonNullElements(key, world);
}
public World2ListModelAdapter(ReadOnlyWorld world, KEY key,
FreerailsPrincipal p) {
this.w = world;
if (null == key)
throw new NullPointerException();
if (null == p)
throw new NullPointerException();
if (null == w)
throw new NullPointerException();
// Check that the principal exists.
if (!world.isPlayer(p))
throw new IllegalArgumentException(p.getName());
elements = new NonNullElements(key, world, p);
}
public int getSize() {
return elements.size();
}
public Object getElementAt(int i) {
elements.gotoRow(i);
return elements.getElement();
}
public void addListDataListener(ListDataListener arg0) {
// TODO Auto-generated method stub
}
public void removeListDataListener(ListDataListener arg0) {
// TODO Auto-generated method stub
}
}

/**
* Generates a move that adds or upgrades a station.
*
* @author Luke
*
*/
public class AddStationPreMove implements PreMove {
private static final long serialVersionUID = 3258131349411148085L;
private final ImPoint p;
private final int ruleNumber;
private final FreerailsPrincipal principal;
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (!(o instanceof AddStationPreMove))
return false;
final AddStationPreMove addStationPreMove = (AddStationPreMove) o;
if (ruleNumber != addStationPreMove.ruleNumber)
return false;
if (!p.equals(addStationPreMove.p))
return false;
if (!principal.equals(addStationPreMove.principal))
return false;
return true;
}
@Override
public int hashCode() {
int result;
result = p.hashCode();
result = 29 * result + ruleNumber;
result = 29 * result + principal.hashCode();
return result;
}
private AddStationPreMove(ImPoint p, int trackRule,
FreerailsPrincipal principal) {
this.p = p;
this.ruleNumber = trackRule;
this.principal = principal;
}
public static AddStationPreMove newStation(ImPoint p, int trackRule,
FreerailsPrincipal principal) {
return new AddStationPreMove(p, trackRule, principal);
}
public static AddStationPreMove upgradeStation(ImPoint p, int trackRule,
FreerailsPrincipal principal) {
return new AddStationPreMove(p, trackRule, principal);
}
public Move generateMove(ReadOnlyWorld world) {
TrackMoveTransactionsGenerator transactionsGenerator = new TrackMoveTransactionsGenerator(
world, principal);
FreerailsTile oldTile = (FreerailsTile) world.getTile(p.x, p.y);
String cityName;
String stationName;
FreerailsTile ft = (FreerailsTile)world.getTile(p.x, p.y);
TrackPiece before = ft.getTrackPiece();
TrackRule trackRule = (TrackRule) world.get(SKEY.TRACK_RULES,
this.ruleNumber);
int owner = ChangeTrackPieceCompositeMove.getOwner(principal, world);
TrackPiece after = new TrackPieceImpl(before.getTrackConfiguration(),
trackRule, owner, ruleNumber);
ChangeTrackPieceMove upgradeTrackMove = new ChangeTrackPieceMove(
before, after, p);
CompositeMove move;
if (!oldTile.getTrackPiece().getTrackRule().isStation()) {
// There isn't already a station here, we need to pick a name and
// add an entry
// to the station list.
CalcNearestCity cNC = new CalcNearestCity(world, p.x, p.y);
try {
cityName = cNC.findNearestCity();
VerifyStationName vSN = new VerifyStationName(world, cityName);
stationName = vSN.getName();
} catch (NoSuchElementException e) {
// there are no cities, this should never happen during a proper
// game. However
// some of the unit tests create stations when there are no
// cities.
stationName = "Central Station #"
+ world.size(principal, KEY.STATIONS);
}
// check the terrain to see if we can build a station on it...
move = AddStationMove.generateMove(world, stationName, p,
upgradeTrackMove, principal);
move = addSupplyAndDemand(move, world);
move = transactionsGenerator.addTransactions(move);
} else {
// Upgrade an existing station.
move = AddStationMove.upgradeStation(upgradeTrackMove);
}
return move;
}
private CompositeMove addSupplyAndDemand(CompositeMove m, ReadOnlyWorld w) {
ImList<Move> moves2 = m.getMoves();
Move[] moves = new Move[moves2.size()];
for (int i = 0; i < moves2.size(); i++) {
moves[i] = moves2.get(i);
}
for (int i = 0; i < moves.length; i++) {
if (moves[i] instanceof AddItemToListMove) {
AddItemToListMove move = (AddItemToListMove) moves[i];
if (move.getKey().equals(KEY.STATIONS)) {
StationModel station = (StationModel) move.getAfter();
CalcCargoSupplyRateAtStation supplyRate;
supplyRate = new CalcCargoSupplyRateAtStation(w, station.x,
station.y, ruleNumber);
StationModel stationAfter = supplyRate
.calculations(station);
moves[i] = new AddItemToListMove(move.getKey(), move
.getIndex(), stationAfter, move.getPrincipal());
}
}
}
return new CompositeMove(moves);
}
}

/**
* @author Luke
*
*/
public class AddTrainPreMove implements PreMove {
private static final long serialVersionUID = 4050201951105069624L;
private final int engineTypeId;
private final ImInts wagons;
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof AddTrainPreMove)) {
return false;
}
final AddTrainPreMove addTrainPreMove = (AddTrainPreMove) o;
if (engineTypeId != addTrainPreMove.engineTypeId) {
return false;
}
if (!point.equals(addTrainPreMove.point)) {
return false;
}
if (!principal.equals(addTrainPreMove.principal)) {
return false;
}
if (!schedule.equals(addTrainPreMove.schedule)) {
return false;
}
if (!wagons.equals(addTrainPreMove.wagons)) {
return false;
}
return true;
}
@Override
public int hashCode() {
int result;
result = engineTypeId;
result = 29 * result + point.hashCode();
result = 29 * result + principal.hashCode();
result = 29 * result + schedule.hashCode();
return result;
}
private final ImPoint point;
private final FreerailsPrincipal principal;
private final ImmutableSchedule schedule;
public AddTrainPreMove(int e, ImInts wags, ImPoint p,
FreerailsPrincipal fp, ImmutableSchedule s) {
engineTypeId = e;
wagons = wags;
point = p;
principal = fp;
schedule = s;
if (null == wags) {
throw new NullPointerException();
}
if (null == p) {
throw new NullPointerException();
}
if (null == fp) {
throw new NullPointerException();
}
if (null == s) {
throw new NullPointerException();
}
}
PathOnTiles initPositionStep1(ReadOnlyWorld w) {
PositionOnTrack[] pp = FlatTrackExplorer.getPossiblePositions(w, point);
FlatTrackExplorer fte = new FlatTrackExplorer(w, pp[0]);
List<Step> steps = new ArrayList<Step>();
int length = calTrainLength();
int distanceTravelled = 0;
PositionOnTrack p = new PositionOnTrack();
while (distanceTravelled < length) {
fte.nextEdge();
fte.moveForward();
p.setValuesFromInt(fte.getPosition());
Step v = p.cameFrom();
distanceTravelled += v.getLength();
steps.add(v);
}
return new PathOnTiles(point, steps);
}
private int calTrainLength() {
TrainModel train = new TrainModel(engineTypeId, wagons, 0);
int length = train.getLength();
return length;
}
TrainMotion initPositionStep2(PathOnTiles path) {
// TODO fix code.
TrainMotion tm = new TrainMotion(path, path.steps(), calTrainLength(),
ConstAcc.STOPPED);
return tm;
}
/**
* Generates a move that does the following.
* <ol>
* <li>Adds the train</li>
* <li>Adds a cargo bundle to represent the cargo the train is
* carrying</li>
* <li>Adds a schedule for the train</li>
* <li>Adds transaction to pay for the train</li>
* <li>Init. the trains position and motion</li>
* </ol>
*
*
*/
public Move generateMove(ReadOnlyWorld w) {
// Add cargo bundle.
int bundleId = w.size(principal, KEY.CARGO_BUNDLES);
ImmutableCargoBundle cargo = ImmutableCargoBundle.EMPTY_BUNDLE;
AddItemToListMove addCargoBundle = new AddItemToListMove(
KEY.CARGO_BUNDLES, bundleId, cargo, principal);
// Add schedule
for (int i = 0; i < schedule.getNumOrders(); i++) {
TrainOrdersModel order = schedule.getOrder(i);
if (!w.boundsContain(principal, KEY.STATIONS, order.stationId)) {
throw new ArrayIndexOutOfBoundsException(String.format("%d", order.stationId));
}
}
int scheduleId = w.size(principal, KEY.TRAIN_SCHEDULES);
AddItemToListMove addSchedule = new AddItemToListMove(
KEY.TRAIN_SCHEDULES, scheduleId, schedule, principal);
// Add train to train list.
TrainModel train = new TrainModel(engineTypeId, wagons, scheduleId,
bundleId);
int trainId = w.size(principal, KEY.TRAINS);
AddItemToListMove addTrain = new AddItemToListMove(KEY.TRAINS, trainId,
train, principal);
// Pay for train.
int quantity = 1;
/* Determine the price of the train. */
EngineType engineType = (EngineType) w.get(SKEY.ENGINE_TYPES,
engineTypeId);
Money price = engineType.getPrice();
Transaction transaction = new AddItemTransaction(
Transaction.Category.TRAIN, engineTypeId, quantity, new Money(
-price.getAmount()));
AddTransactionMove transactionMove = new AddTransactionMove(principal,
transaction);
// Setup and add train position.
PathOnTiles path = initPositionStep1(w);
TrainMotion motion = initPositionStep2(path);
Move addPosition = new AddActiveEntityMove(motion, trainId,
principal);
return new CompositeMove(addCargoBundle, addSchedule, addTrain,
transactionMove, addPosition);
}
}

/**
* Generates the balance sheet - note, its fields are read using reflection so
* don't change their names.
*
* @author Luke
*
*/
public class BalanceSheetGenerator {
GameTime from;
GameTime to;
final ReadOnlyWorld w;
final FreerailsPrincipal principal;
private GameCalendar cal;
public String year;
public Stats total;
public Stats ytd;
public BalanceSheetGenerator(ReadOnlyWorld w, FreerailsPrincipal principal) {
this.w = w;
this.principal = principal;
cal = (GameCalendar) w.get(ITEM.CALENDAR);
// Calculate totals
GameTime time = w.currentTime();
final int startyear = cal.getYear(time.getTicks());
year = String.valueOf(startyear);
GameTime startOfYear = new GameTime(cal.getTicks(startyear));
GameTime[] totalTimeInterval = new GameTime[] { GameTime.BIG_BANG,
GameTime.END_OF_THE_WORLD };
total = new Stats(w, principal, totalTimeInterval);
GameTime[] ytdTimeInterval = new GameTime[] { startOfYear,
GameTime.END_OF_THE_WORLD };
ytd = new Stats(w, principal, ytdTimeInterval);
}
public static Money calTrackTotal(Transaction.Category category,
ReadOnlyWorld w, FreerailsPrincipal principal, GameTime startTime) {
ItemsTransactionAggregator aggregator = new ItemsTransactionAggregator(
w, principal);
aggregator.setCategory(TRACK);
long amount = 0;
for (int i = 0; i < w.size(SKEY.TRACK_RULES); i++) {
TrackRule trackRule = (TrackRule) w.get(SKEY.TRACK_RULES, i);
long trackValue = trackRule.getPrice().getAmount();
GameTime[] times = new GameTime[] { startTime,
GameTime.END_OF_THE_WORLD };
aggregator.setType(i);
aggregator.setTimes(times);
ItemsTransactionAggregator.QuantitiesAndValues qnv = aggregator
.calculateQuantitiesAndValues();
int quantity = qnv.quantities[0];
amount += trackValue * quantity
/ TrackConfiguration.LENGTH_OF_STRAIGHT_TRACK_PIECE;
}
return new Money(amount);
}
public static class Stats {
public Stats(ReadOnlyWorld w, FreerailsPrincipal principal, final GameTime[] totalTimeInterval){
TransactionAggregator operatingFundsAggregator = new TransactionAggregator(w,
principal) {
@Override
protected boolean condition(int i) {
int transactionTicks = w.getTransactionTimeStamp(
principal, i).getTicks();
int from = totalTimeInterval[0].getTicks();
int to = totalTimeInterval[1].getTicks();
return transactionTicks >= from && transactionTicks <=to;
}
};
operatingFunds= operatingFundsAggregator.calculateValue();
track = calTrackTotal(TRACK, w, principal, totalTimeInterval[0]);
ItemsTransactionAggregator aggregator = new ItemsTransactionAggregator(
w, principal);
aggregator.setTimes(totalTimeInterval);
aggregator.setCategory(STATIONS);
stations = aggregator.calculateValue();
aggregator.setCategory(TRAIN);
rollingStock = aggregator.calculateValue();
aggregator.setCategory(INDUSTRIES);
industries = aggregator.calculateValue();
aggregator.setCategory(BOND);
loans = aggregator.calculateValue();
aggregator.setCategory(ISSUE_STOCK);
equity= aggregator.calculateValue();
//If we don't initialize this variable
//we get a NPE when we don't own any stock in others RRs
otherRrStock = new Money(0);
int thisPlayerId = w.getID(principal);
StockPrice[] stockPrices = (new StockPriceCalculator(w)).calculate();
for (int playerId = 0; playerId < w.getNumberOfPlayers(); playerId++) {
aggregator.setCategory(TRANSFER_STOCK);
aggregator.setType(thisPlayerId);
int quantity = aggregator.calculateQuantity();
if (playerId == thisPlayerId) {
treasuryStock = new Money(quantity
* stockPrices[playerId].currentPrice.getAmount());
} else {
otherRrStock = new Money(quantity
* stockPrices[playerId].currentPrice.getAmount()
+ otherRrStock.getAmount());
}
}
calProfit();
}
public Money operatingFunds;
public Money track;
public Money stations;
public Money rollingStock;
public Money industries;
public Money loans;
public Money equity;
public Money treasuryStock;
public Money otherRrStock;
public Money profit;
private void calProfit(){
long profitValue = operatingFunds.getAmount() + track.getAmount()
+ stations.getAmount() + rollingStock.getAmount()
+ industries.getAmount() + loans.getAmount()
+ equity.getAmount() + treasuryStock.getAmount()
+ otherRrStock.getAmount();
profit= new Money(profitValue);
}
}
}

/**
* GraphExplorer that explorers possible track placements, the ints it returns
* are encoded PositionOnTrack objects.
*
* @author Luke
*
*/
public class BuildTrackExplorer implements GraphExplorer {
private static final TrackConfiguration TILE_CENTER = TrackConfiguration
.getFlatInstance("000010000");
private boolean beforeFirst = true;
final PositionOnTrack currentBranch = PositionOnTrack.createComingFrom(0,
0, Step.NORTH);
final private PositionOnTrack currentPosition = PositionOnTrack
.createComingFrom(0, 0, Step.NORTH);
private int directionInt = 0;
private final ImPoint target;
private BuildTrackStrategy buildTrackStrategy;
private boolean usingExistingTrack = false;
private final ReadOnlyWorld world;
private final FreerailsPrincipal principal;
public BuildTrackExplorer(ReadOnlyWorld w, FreerailsPrincipal principal) {
this(w, principal, null, new ImPoint(0, 0));
}
public BuildTrackExplorer(ReadOnlyWorld w, FreerailsPrincipal principal,
ImPoint start, ImPoint target) {
world = w;
this.principal = principal;
PositionOnTrack pos;
if (null == start) {
pos = new PositionOnTrack();
} else {
pos = PositionOnTrack
.createComingFrom(start.x, start.y, Step.NORTH);
}
currentPosition.setValuesFromInt(pos.toInt());
directionInt = 0;
this.target = target;
buildTrackStrategy = BuildTrackStrategy.getDefault(w);
}
/**
* <p>
* Tests whether we can build track in the direction specified by
* m_direction.
* </p>
*
* <p>
* If we enter a tile from a given direction, the tiles we can build track
* to depend on the following. (1) The terrain type of the surrounding tiles -
* track can only be built on certain terrain types. (2) The direction we
* entered the current tile from. (3) Any existing track on the current tile -
* limits possible track configurations. (4) The terrain type of the current
* tile - terrain type determines which track types and hence which track
* configurations can be built.
* </p>
*
*/
private boolean canBuildTrack() {
// Check that we are not doubling back on ourselves.
Step opposite2current = currentPosition.cameFrom().getOpposite();
int currentX = currentPosition.getX();
int currentY = currentPosition.getY();
int directionWeCameFrom = opposite2current.getID();
int directionWeCameFromPlus = (directionWeCameFrom + 1) % 8;
int directionWeCameFromMinus = (directionWeCameFrom + 7) % 8;
if (directionInt == directionWeCameFrom
|| directionInt == directionWeCameFromPlus
|| directionInt == directionWeCameFromMinus) {
return false;
}
// Check that we are not going off the map.
Step directionOfNextTile = Step.getInstance(directionInt);
int newX = currentX + directionOfNextTile.getDx();
int newY = currentY + directionOfNextTile.getDy();
if (!world.boundsContain(newX, newY)) {
return false;
}
TrackRule rule4nextTile;
TrackRule rule4lastTile;
// Determine the track rule for the next tile.
final FreerailsTile nextTile = (FreerailsTile) world.getTile(newX,
newY);
// Check there is not another players track at nextTile.
if (nextTile.hasTrack()) {
if (nextTile.getTrackPiece().getOwnerID() != world.getID(principal)) {
return false;
}
}
rule4nextTile = getAppropriateTrackRule(newX, newY);
if (null == rule4nextTile) {
return false; // We can't build track on the tile.
}
rule4lastTile = getAppropriateTrackRule(currentX, currentY);
if (null == rule4lastTile) {
return false; // We can't build track on the tile.
}
// Determine the track rule for the current tile.
FreerailsTile currentTile = (FreerailsTile) world.getTile(currentX,
currentY);
// Check for illegal track configurations.
final TrackConfiguration trackAlreadyPresent1 = currentTile
.getTrackPiece().getTrackConfiguration();
final TrackConfiguration trackAlreadyPresent2 = nextTile
.getTrackPiece().getTrackConfiguration();
TrackConfiguration fromConfig = trackAlreadyPresent1;
fromConfig = TrackConfiguration.add(fromConfig, opposite2current);
fromConfig = TrackConfiguration.add(fromConfig, TILE_CENTER);
Step goingTo = Step.getInstance(directionInt);
fromConfig = TrackConfiguration.add(fromConfig, goingTo);
if (!rule4lastTile.trackPieceIsLegal(fromConfig)) {
return false;
}
// Check for diagonal conflicts.
if (directionOfNextTile.isDiagonal()) {
int x2check = currentX;
int y2check = currentY + directionOfNextTile.deltaY;
// We did a bounds check above.
assert (world.boundsContain(x2check, y2check));
FreerailsTile tile2Check = (FreerailsTile) world.getTile(x2check,
y2check);
TrackConfiguration config2check = tile2Check
.getTrackPiece().getTrackConfiguration();
Step vector2check = Step.getInstance(directionOfNextTile.deltaX,
-directionOfNextTile.deltaY);
if (config2check.contains(vector2check)) {
// then we have a diagonal conflict.
return false;
}
}
// Check for illegal track configurations on the tile we are entering.
TrackConfiguration fromConfig2 = trackAlreadyPresent2;
fromConfig2 = TrackConfiguration.add(fromConfig2, TILE_CENTER);
Step goingBack = Step.getInstance(directionInt).getOpposite();
fromConfig2 = TrackConfiguration.add(fromConfig2, goingBack);
if (!rule4nextTile.trackPieceIsLegal(fromConfig2)) {
return false;
}
/*
* Set the using existing track. We do this because a path that uses
* existing track is cheaper to build.
*/
usingExistingTrack = trackAlreadyPresent1.contains(goingTo);
return true;
}
private TrackRule getAppropriateTrackRule(int x, int y) {
final FreerailsTile tile = (FreerailsTile) world.getTile(x, y);
TrackRule rule;
if (!tile.hasTrack()) {
int terrainTypeID = tile.getTerrainTypeID();
int trackRuleID = buildTrackStrategy.getRule(terrainTypeID);
if (trackRuleID == -1) {
return null; // Can't build on this terrain!
}
rule = (TrackRule) world.get(SKEY.TRACK_RULES, trackRuleID);
} else {
rule = tile.getTrackPiece().getTrackRule();
}
return rule;
}
/**
* Calculates a cost figure incorporating the distance and the cost of any
* new track.
*/
public int getEdgeCost() {
if (beforeFirst) {
throw new IllegalStateException();
}
Step edgeDirection = Step.getInstance(directionInt - 1);
double length = edgeDirection.getLength();
final int DISTANCE_COST = 10000; // Same as the cost of standard
// track.
int cost = (int) Math.round(DISTANCE_COST * length);
if (!usingExistingTrack) {
int[] x = { currentPosition.getX(),
currentPosition.getX() + edgeDirection.deltaX };
int[] y = { currentPosition.getY(),
currentPosition.getY() + edgeDirection.deltaY };
TrackRule ruleA = getAppropriateTrackRule(x[0], y[0]);
TrackRule ruleB = getAppropriateTrackRule(x[1], y[1]);
/*
* If there is a station at either of the points, don't include its
* price in the cost calculation since it has already been paid.
* Otherwise, add the cost of building the track.
*/
long priceA = ruleA.getPrice().getAmount();
long priceB = ruleB.getPrice().getAmount();
cost += length * (priceA + priceB);
// Add fixed cost if tile b does not have the desired track type.
FreerailsTile a = (FreerailsTile) world.getTile(x[0], y[0]);
TrackRule currentRuleA = a.getTrackPiece().getTrackRule();
if (!currentRuleA.equals(ruleA)) {
assert (!currentRuleA.isStation()); // We shouldn't be upgrading
// a station.
cost += ruleA.getFixedCost().getAmount() * Step.TILE_DIAMETER;
}
}
return cost;
}
public int getH() {
int xDistance = (target.x - currentPosition.getX())
* Step.TILE_DIAMETER;
int yDistance = (target.y - currentPosition.getY())
* Step.TILE_DIAMETER;
int sumOfSquares = (xDistance * xDistance + yDistance * yDistance);
return (int) Math.sqrt(sumOfSquares);
}
public int getPosition() {
return currentPosition.toInt();
}
public int getVertexConnectedByEdge() {
if (beforeFirst) {
throw new IllegalStateException();
}
return currentBranch.toInt();
}
public boolean hasNextEdge() {
while (directionInt < 8) {
if (canBuildTrack()) {
return true;
}
directionInt++;
}
return false;
}
public void moveForward() {
if (beforeFirst) {
throw new IllegalStateException();
}
setPosition(this.getVertexConnectedByEdge());
}
public void nextEdge() {
if (!hasNextEdge()) {
throw new NoSuchElementException();
}
// The direction we are moving relative to the current position.
Step direction = Step.getInstance(directionInt);
currentBranch.setCameFrom(direction);
currentBranch.setX(currentPosition.getX() + direction.getDx());
currentBranch.setY(currentPosition.getY() + direction.getDy());
directionInt++;
beforeFirst = false;
}
public void setPosition(int vertex) {
currentPosition.setValuesFromInt(vertex);
directionInt = 0;
}
public void setBuildTrackStrategy(BuildTrackStrategy trackStrategy) {
if (null == trackStrategy)
throw new NullPointerException();
buildTrackStrategy = trackStrategy;
}
}

/**
* A BuildTrackStrategy determines which track types to build (or upgrade to) on
* different terrains.
*
* @author Luke
*/
public class BuildTrackStrategy {
private final int[] rules;
public static BuildTrackStrategy getSingleRuleInstance(int trackTypeID,
ReadOnlyWorld w) {
int noTerrainTypes = w.size(SKEY.TERRAIN_TYPES);
int[] newRules = new int[noTerrainTypes];
for (int i = 0; i < noTerrainTypes; i++) {
newRules[i] = trackTypeID;
}
return new BuildTrackStrategy(newRules);
}
public static BuildTrackStrategy getMultipleRuleInstance(
ArrayList<Integer> ruleIDs, ReadOnlyWorld w) {
int[] rulesArray = generateRules(ruleIDs, w);
return new BuildTrackStrategy(rulesArray);
}
public static BuildTrackStrategy getDefault(ReadOnlyWorld w) {
ArrayList<Integer> allowable = new ArrayList<Integer>();
allowable.add(getCheapest(TrackRule.TrackCategories.track, w));
allowable.add(getCheapest(TrackRule.TrackCategories.bridge, w));
allowable.add(getCheapest(TrackRule.TrackCategories.tunnel, w));
return new BuildTrackStrategy(generateRules(allowable, w));
}
private static Integer getCheapest(TrackRule.TrackCategories category,
ReadOnlyWorld w) {
TrackRule cheapest = null;
Integer cheapestID = null;
for (int i = 0; i < w.size(SKEY.TRACK_RULES); i++) {
TrackRule rule = (TrackRule) w.get(SKEY.TRACK_RULES, i);
if (rule.getCategory().equals(category)) {
if (null == cheapest
|| cheapest.getPrice().getAmount() > rule.getPrice()
.getAmount()) {
cheapest = rule;
cheapestID = new Integer(i);
}
}
}
return cheapestID;
}
private static int[] generateRules(ArrayList<Integer> allowable,
ReadOnlyWorld w) {
int noTerrainTypes = w.size(SKEY.TERRAIN_TYPES);
int[] newRules = new int[noTerrainTypes];
for (int i = 0; i < noTerrainTypes; i++) {
TerrainType terrainType = (TerrainType) w
.get(SKEY.TERRAIN_TYPES, i);
newRules[i] = -1; // the default value.
for (Integer rule : allowable) {
if (null != rule) {
TrackRule trackRule = (TrackRule) w.get(SKEY.TRACK_RULES,
rule.intValue());
if (trackRule.canBuildOnThisTerrainType(terrainType
.getCategory())) {
newRules[i] = rule.intValue();
break;
}
}
}
}
return newRules;
}
/** Creates a new instance of BuildTrackStrategy */
private BuildTrackStrategy(int[] r) {
rules = r;
}
public int getRule(int terrainType) {
return rules[terrainType];
}
}

/**
* This class probes the tiles adjacent to a station for what cargo they supply,
* demand, and convert and then returns a vector of these rates.
*
* @author Scott Bennett
* @author Luke Created: 9th May 2003
*/
public class CalcCargoSupplyRateAtStation {
private static final Logger logger = Logger
.getLogger(CalcCargoSupplyRateAtStation.class.getName());
/**
* The threshold that demand for a cargo must exceed before the station
* demands the cargo.
*/
private static final int PREREQUISITE_FOR_DEMAND = 16;
private final int[] converts;
private final int[] demand;
private final Vector<CargoElementObject> supplies;
private final ReadOnlyWorld w;
private int x;
private int y;
private int stationRadius;
/**
* Call this constructor if the station does not exist yet.
*
* @param trackRuleNo
* the station type.
*/
public CalcCargoSupplyRateAtStation(ReadOnlyWorld world, int X, int Y,
int trackRuleNo) {
this.w = world;
this.x = X;
this.y = Y;
TrackRule trackRule = (TrackRule) w.get(SKEY.TRACK_RULES, trackRuleNo);
stationRadius = trackRule.getStationRadius();
supplies = new Vector<CargoElementObject>();
populateSuppliesVector();
int numCargoTypes = w.size(SKEY.CARGO_TYPES);
demand = new int[numCargoTypes];
converts = ConvertedAtStation.emptyConversionArray(numCargoTypes);
}
/** Call this constructor if the station already exists. */
public CalcCargoSupplyRateAtStation(ReadOnlyWorld world, int X, int Y) {
this(world, X, Y, findTrackRule(X, Y, world));
}
public ConvertedAtStation getConversion() {
return new ConvertedAtStation(this.converts);
}
public Demand4Cargo getDemand() {
boolean[] demandboolean = new boolean[w.size(SKEY.CARGO_TYPES)];
for (int i = 0; i < w.size(SKEY.CARGO_TYPES); i++) {
if (demand[i] >= PREREQUISITE_FOR_DEMAND) {
demandboolean[i] = true;
}
}
return new Demand4Cargo(demandboolean);
}
private void incrementSupplyAndDemand(int i, int j) {
int tileTypeNumber = ((FreerailsTile) w.getTile(i, j))
.getTerrainTypeID();
TerrainType terrainType = (TerrainType) w.get(SKEY.TERRAIN_TYPES,
tileTypeNumber);
// Calculate supply.
ImList<Production> production = terrainType.getProduction();
// loop through the production array and increment
// the supply rates for the station
for (int m = 0; m < production.size(); m++) {
int type = production.get(m).getCargoType();
int rate = production.get(m).getRate();
// loop through supplies vector and increment the cargo values as
// required
updateSupplyRate(type, rate);
}
// Now calculate demand.
ImList<Consumption> consumption = terrainType.getConsumption();
for (int m = 0; m < consumption.size(); m++) {
int type = consumption.get(m).getCargoType();
int prerequisite = consumption.get(m).getPrerequisite();
// The prerequisite is the number tiles of this type that must
// be within the station radius before the station demands the
// cargo.
demand[type] += PREREQUISITE_FOR_DEMAND / prerequisite;
}
ImList<Conversion> conversion = terrainType.getConversion();
for (int m = 0; m < conversion.size(); m++) {
int type = conversion.get(m).getInput();
// Only one tile that converts the cargo type is needed for the
// station to demand the cargo type.
demand[type] += PREREQUISITE_FOR_DEMAND;
converts[type] = conversion.get(m).getOutput();
}
}
private void populateSuppliesVector() {
// fill supplies vector with 0 values for all cargo types
// get the correct list of cargoes from the world object
CargoElementObject tempCargoElement;
for (int i = 0; i < w.size(SKEY.CARGO_TYPES); i++) {
// cT = (CargoType) w.get(SKEY.CARGO_TYPES, i);
tempCargoElement = new CargoElementObject(0, i);
supplies.add(tempCargoElement);
}
}
public Vector<CargoElementObject> scanAdjacentTiles() {
int stationDiameter = stationRadius * 2 + 1;
Rectangle stationRadiusRect = new Rectangle(x - stationRadius, y
- stationRadius, stationDiameter, stationDiameter);
Rectangle mapRect = new Rectangle(0, 0, w.getMapWidth(), w
.getMapHeight());
Rectangle tiles2scan = stationRadiusRect.intersection(mapRect);
logger.fine("stationRadiusRect=" + stationRadiusRect);
logger.fine("mapRect=" + mapRect);
logger.fine("tiles2scan=" + tiles2scan);
// Look at the terrain type of each tile and retrieve the cargo
// supplied.
// The station radius determines how many tiles each side we look at.
for (int i = tiles2scan.x; i < (tiles2scan.x + tiles2scan.width); i++) {
for (int j = tiles2scan.y; j < (tiles2scan.y + tiles2scan.height); j++) {
incrementSupplyAndDemand(i, j);
}
}
// return the supplied cargo rates
return supplies;
}
private static int findTrackRule(int xx, int yy, ReadOnlyWorld w) {
FreerailsTile tile = (FreerailsTile) w.getTile(xx, yy);
int ruleNumber = tile.getTrackPiece().getTrackTypeID();
return ruleNumber;
}
private void updateSupplyRate(int type, int rate) {
// loop through supplies vector and increment the cargo values as
// required
for (int n = 0; n < supplies.size(); n++) {
CargoElementObject tempElement = supplies.elementAt(n);
if (tempElement.getType() == type) {
// cargo types are the same, so increment the rate in supply
// with the rate.
tempElement.setRate(tempElement.getRate() + rate);
break; // no need to go through the rest if we've found a match
}
}
}
/**
*
* Process each existing station, updating what is supplied to it.
*
* @param station
* A StationModel object to be processed
*
*/
public StationModel calculations(StationModel station) {
int[] cargoSupplied = new int[w.size(SKEY.CARGO_TYPES)];
Vector<CargoElementObject> supply = scanAdjacentTiles();
// grab the supply rates from the vector
for (int i = 0; i < supply.size(); i++) {
cargoSupplied[i] = supply.get(i).getRate();
}
// set the supply rates for the current station
SupplyAtStation supplyAtStation = new SupplyAtStation(cargoSupplied);
station = new StationModel(station, supplyAtStation);
station = new StationModel(station, getDemand());
station = new StationModel(station, getConversion());
return station;
}
}

/**
*
*
* Class to find the nearest city and return that name, so that a station can be
* named appropriately. Date: 12th April 2003
*
* @author Scott Bennett
*/
public class CalcNearestCity {
private final int x;
private final int y;
private final ReadOnlyWorld w;
public CalcNearestCity(ReadOnlyWorld world, int x, int y) {
this.w = world;
this.x = x;
this.y = y;
}
public String findNearestCity() {
double cityDistance;
String cityName = null;
double tempDistance;
CityModel tempCity;
if (w.size(SKEY.CITIES) > 0) {
tempCity = (CityModel) w.get(SKEY.CITIES, 0);
cityDistance = getDistance(tempCity.getCityX(), tempCity.getCityY());
cityName = tempCity.getCityName();
for (int i = 1; i < w.size(SKEY.CITIES); i++) {
tempCity = (CityModel) w.get(SKEY.CITIES, i);
tempDistance = getDistance(tempCity.getCityX(), tempCity
.getCityY());
if (tempDistance < cityDistance) {
cityDistance = tempDistance;
cityName = tempCity.getCityName();
}
}
return cityName;
}
throw new NoSuchElementException();
}
private double getDistance(int cityX, int cityY) {
double distance = 0;
double a = (this.x - cityX) * (this.x - cityX);
double b = (this.y - cityY) * (this.y - cityY);
distance = Math.sqrt(a + b);
return distance;
}
}

/**
* Small data object to store the rate of supply of a cargo.
*
* @author Scott Bennett Date: 14 May 2003
*/
public class CargoElementObject {
private int rate;
private final int type;
public CargoElementObject(int rate, int type) {
this.rate = rate;
this.type = type;
}
public int getRate() {
return rate;
}
public void setRate(int rate) {
this.rate = rate;
}
public int getType() {
return type;
}
}

/**
* Defines the methods that the server can call on a client using a
* Message2Client.
*
* @see Message2Client
* @author Luke
*
*/
public interface ClientControlInterface {
public enum ClientProperty {CONNECTED_CLIENTS, MAPS_AVAILABLE, SAVED_GAMES}
/** Called when a new game is started or a game is loaded. */
void setGameModel(FreerailsMutableSerializable world);
/** Sets a property, for example, the list of saved games. */
void setProperty(ClientProperty propertyName, Serializable value);
}

/**
* Displays text that can be selected with the mouse and copied to the clipboard.
*
* @author Luke
*/
public class CopyableTextJPanel extends javax.swing.JPanel {
private static final long serialVersionUID = 4076159955353400345L;
/** Creates new form CopyableTextJPanel */
public CopyableTextJPanel() {
initComponents();
}
public void setText(String s){
this.jTextArea1.setText(s);
}
/** This method is called from within the constructor to
* initialize the form.
* WARNING: Do NOT modify this code. The content of this method is
* always regenerated by the Form Editor.
*/
// <editor-fold defaultstate="collapsed" desc=" Generated Code ">//GEN-BEGIN:initComponents
private void initComponents() {
java.awt.GridBagConstraints gridBagConstraints;
jPopupMenu1 = new javax.swing.JPopupMenu();
copyItem = new javax.swing.JMenuItem();
selectAllItem = new javax.swing.JMenuItem();
jScrollPane1 = new javax.swing.JScrollPane();
jTextArea1 = new javax.swing.JTextArea();
copyItem.setAccelerator(javax.swing.KeyStroke.getKeyStroke(java.awt.event.KeyEvent.VK_C, java.awt.event.InputEvent.CTRL_MASK));
copyItem.setText("Copy");
copyItem.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
copyItemActionPerformed(evt);
}
});
jPopupMenu1.add(copyItem);
selectAllItem.setAccelerator(javax.swing.KeyStroke.getKeyStroke(java.awt.event.KeyEvent.VK_A, java.awt.event.InputEvent.CTRL_MASK));
selectAllItem.setText("Select All");
selectAllItem.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
selectAllItemActionPerformed(evt);
}
});
jPopupMenu1.add(selectAllItem);
setLayout(new java.awt.GridBagLayout());
setPreferredSize(new java.awt.Dimension(500, 300));
jTextArea1.setEditable(false);
jTextArea1.setText("dsfasd\n\nsad\nf\nasd\nfa\nsdf\nas\ndf\nas\ndf\nads\nf\nasd\nf\nads\nf\ndsa\nf\ndsa\nf\ndasf\na\ndsf\nads\nf\nasd\nf\nasd\nf\n\nasdf");
jTextArea1.setWrapStyleWord(true);
jTextArea1.setOpaque(false);
jTextArea1.addMouseListener(new java.awt.event.MouseAdapter() {
@Override
public void mouseClicked(java.awt.event.MouseEvent evt) {
jTextArea1MouseClicked(evt);
}
});
jScrollPane1.setViewportView(jTextArea1);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 0;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
add(jScrollPane1, gridBagConstraints);
}
// </editor-fold>//GEN-END:initComponents
private void selectAllItemActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_selectAllItemActionPerformed
jTextArea1.selectAll();
}//GEN-LAST:event_selectAllItemActionPerformed
private void copyItemActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_copyItemActionPerformed
jTextArea1.copy();
}//GEN-LAST:event_copyItemActionPerformed
private void jTextArea1MouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_jTextArea1MouseClicked
if(SwingUtilities.isRightMouseButton(evt)){
jPopupMenu1.show(jTextArea1, evt.getX(), evt.getY());
}
}//GEN-LAST:event_jTextArea1MouseClicked
// Variables declaration - do not modify//GEN-BEGIN:variables
javax.swing.JMenuItem copyItem;
javax.swing.JPopupMenu jPopupMenu1;
javax.swing.JScrollPane jScrollPane1;
javax.swing.JTextArea jTextArea1;
javax.swing.JMenuItem selectAllItem;
// End of variables declaration//GEN-END:variables
}

/**
* This class generates moves that transfer cargo between train and the stations
* it stops at - it also handles cargo conversions that occur when cargo is
* dropped off.
*
* @author Scott Bennett
* @author Luke Lindsay Date Created: 4 June 2003
*/
public class DropOffAndPickupCargoMoveGenerator {
private final ReadOnlyWorld w;
private final TrainAccessor train;
private final int trainId;
private int trainBundleId;
private final int stationId;
private int stationBundleId;
private MutableCargoBundle stationAfter;
private MutableCargoBundle stationBefore;
private MutableCargoBundle trainAfter;
private MutableCargoBundle trainBefore;
private ArrayList<Move> moves;
private final FreerailsPrincipal principal;
private boolean waitingForFullLoad;
private boolean autoConsist;
private ImInts consist = new ImInts();
/**
* Stores the type and quantity of cargo in a wagon.
*
* @author Luke
*/
private static class WagonLoad implements Comparable<WagonLoad> {
final int quantity;
final int cargoType;
public int compareTo(WagonLoad test) {
return quantity - test.quantity;
}
WagonLoad(int q, int t) {
quantity = q;
cargoType = t;
}
}
/**
* Constructor.
*
* @param trainNo
* ID of the train
* @param stationNo
* ID of the station
* @param world
* The world object
*/
public DropOffAndPickupCargoMoveGenerator(int trainNo, int stationNo, ReadOnlyWorld world,
FreerailsPrincipal p, boolean waiting, boolean autoConsist) {
principal = p;
trainId = trainNo;
stationId = stationNo;
w = world;
this.autoConsist = autoConsist;
this.waitingForFullLoad = waiting;
train = new TrainAccessor(w, principal, trainNo);
consist = train.getTrain().getConsist();
getBundles();
processTrainBundle(); // ie. unload train / dropoff cargo
if (autoConsist) {
ArrayList<WagonLoad> wagonsAvailable = new ArrayList<WagonLoad>();
assert (train.equals(world.get(principal, KEY.TRAINS, this.trainId)));
Schedule schedule = train.getSchedule();
TrainOrdersModel order = schedule.getOrder(schedule.getOrderToGoto());
int nextStationId = order.stationId;
StationModel stationModel = (StationModel) w
.get(principal, KEY.STATIONS, nextStationId);
Demand4Cargo demand = stationModel.getDemand();
for (int i = 0; i < w.size(SKEY.CARGO_TYPES); i++) {
// If this cargo is demanded at the next scheduled station.
if (demand.isCargoDemanded(i)) {
int amount = stationAfter.getAmount(i);
while (amount > 0) {
int amount2remove = Math.min(amount, WagonType.UNITS_OF_CARGO_PER_WAGON);
amount -= amount2remove;
// Don't bother with less than half a wagon load.
if (amount2remove * 2 > WagonType.UNITS_OF_CARGO_PER_WAGON) {
wagonsAvailable.add(new WagonLoad(amount2remove, i));
}
}
}
}
Collections.sort(wagonsAvailable);
int numWagons2add = Math.min(wagonsAvailable.size(), 3);
int[] temp = new int[numWagons2add];
for (int i = 0; i < numWagons2add; i++) {
WagonLoad wagonload = wagonsAvailable.get(i);
temp[i] = wagonload.cargoType;
}
consist = new ImInts(temp);
}
processStationBundle(); // ie. load train / pickup cargo
}
public Move generateMove() {
// The methods that calculate the before and after bundles could be
// called from here.
ChangeCargoBundleMove changeAtStation = new ChangeCargoBundleMove(stationBefore
.toImmutableCargoBundle(), stationAfter.toImmutableCargoBundle(), stationBundleId,
principal);
ChangeCargoBundleMove changeOnTrain = new ChangeCargoBundleMove(trainBefore
.toImmutableCargoBundle(), trainAfter.toImmutableCargoBundle(), trainBundleId,
principal);
moves.add(TransferCargoAtStationMove.CHANGE_AT_STATION_INDEX, changeAtStation);
moves.add(TransferCargoAtStationMove.CHANGE_ON_TRAIN_INDEX, changeOnTrain);
if (autoConsist) {
int engine = train.getTrain().getEngineType();
Move m = ChangeTrainMove.generateMove(this.trainId, train.getTrain(), engine, consist, principal);
moves.add(m);
} else if (waitingForFullLoad) {
// Only generate a move if there is some cargo to add..
if (changeOnTrain.beforeEqualsAfter())
return null;
}
TransferCargoAtStationMove move = new TransferCargoAtStationMove(moves, waitingForFullLoad);
assert move.getChangeAtStation() == changeAtStation;
assert move.getChangeOnTrain() == changeOnTrain;
return move;
}
private void getBundles() {
TrainModel trainModel = ((TrainModel) w.get(principal, KEY.TRAINS, trainId));
trainBundleId = trainModel.getCargoBundleID();
trainBefore = getCopyOfBundle(trainBundleId);
trainAfter = getCopyOfBundle(trainBundleId);
StationModel stationModel = ((StationModel) w.get(principal, KEY.STATIONS, stationId));
stationBundleId = stationModel.getCargoBundleID();
stationAfter = getCopyOfBundle(stationBundleId);
stationBefore = getCopyOfBundle(stationBundleId);
}
private MutableCargoBundle getCopyOfBundle(int id) {
FreerailsSerializable fs = w.get(principal, KEY.CARGO_BUNDLES, id);
ImmutableCargoBundle ibundle = (ImmutableCargoBundle) fs;
return new MutableCargoBundle(ibundle);
}
private void processTrainBundle() {
Iterator<CargoBatch> batches = trainAfter.toImmutableCargoBundle().cargoBatchIterator();
StationModel station = (StationModel) w.get(principal, KEY.STATIONS, stationId);
MutableCargoBundle cargoDroppedOff = new MutableCargoBundle();
// Unload the cargo that the station demands
while (batches.hasNext()) {
CargoBatch cb = batches.next();
// if the cargo is demanded and its not from this station
// originally...
Demand4Cargo demand = station.getDemand();
int cargoType = cb.getCargoType();
if ((demand.isCargoDemanded(cargoType)) && (stationId != cb.getStationOfOrigin())) {
int amount = trainAfter.getAmount(cb);
cargoDroppedOff.addCargo(cb, amount);
// Now perform any conversions..
ConvertedAtStation converted = station.getConverted();
if (converted.isCargoConverted(cargoType)) {
int newCargoType = converted.getConversion(cargoType);
CargoBatch newCargoBatch = new CargoBatch(newCargoType, station.x, station.y,
0, stationId);
stationAfter.addCargo(newCargoBatch, amount);
}
trainAfter.setAmount(cb, 0);
}
}
moves = ProcessCargoAtStationMoveGenerator.processCargo(w, cargoDroppedOff, this.stationId,
principal, trainId);
// Unload the cargo that there isn't space for on the train regardless
// of whether the station
// demands it.
ImInts spaceAvailable = train.spaceAvailable();
for (int cargoType = 0; cargoType < spaceAvailable.size(); cargoType++) {
int quantity = spaceAvailable.get(cargoType);
if (quantity < 0) {
int amount2transfer = -quantity;
transferCargo(cargoType, amount2transfer, trainAfter, stationAfter);
}
}
}
/** Transfer cargo from the station to the train subject to the space available on the train.
*/
private void processStationBundle() {
ImInts spaceAvailable = TrainAccessor.spaceAvailable2(w, trainAfter.toImmutableCargoBundle(), consist);
for (int cargoType = 0; cargoType < spaceAvailable.size(); cargoType++) {
int quantity = spaceAvailable.get(cargoType);
int amount2transfer = Math.min(quantity, stationAfter
.getAmount(cargoType));
transferCargo(cargoType, amount2transfer, stationAfter, trainAfter);
}
}
public boolean isCargo2Transfer() {
ImInts spaceAvailable = train.spaceAvailable();
int total = 0;
for (int cargoType = 0; cargoType < w.size(SKEY.CARGO_TYPES); cargoType++) {
int quantity = spaceAvailable.get(cargoType);
int amount2transfer = Math.min(quantity, stationAfter
.getAmount(cargoType));
total += amount2transfer;
}
return total > 0;
}
/**
* Move the specified quantity of the specified cargotype from one bundle to
* another.
*/
private static void transferCargo(int cargoTypeToTransfer, int amountToTransfer,
MutableCargoBundle from, MutableCargoBundle to) {
if (0 == amountToTransfer) {
return;
}
Iterator<CargoBatch> batches = from.toImmutableCargoBundle().cargoBatchIterator();
int amountTransferredSoFar = 0;
while (batches.hasNext() && amountTransferredSoFar < amountToTransfer) {
CargoBatch cb = batches.next();
if (cb.getCargoType() == cargoTypeToTransfer) {
int amount = from.getAmount(cb);
int amountOfThisBatchToTransfer;
if (amount < amountToTransfer - amountTransferredSoFar) {
amountOfThisBatchToTransfer = amount;
from.setAmount(cb, 0);
} else {
amountOfThisBatchToTransfer = amountToTransfer - amountTransferredSoFar;
from.addCargo(cb, -amountOfThisBatchToTransfer);
}
to.addCargo(cb, amountOfThisBatchToTransfer);
amountTransferredSoFar += amountOfThisBatchToTransfer;
}
}
}
}

/**
* Gathers the financial data for a company.
*
* @author Luke
* @author smackay
*/
public class FinancialDataGatherer extends TransactionAggregator {
private int totalShares = 100000;
private final int playerID;
private int bonds;
private int[] stockInRRs;
private int[] stockInThisRRs;
@Override
protected void incrementRunningTotal(int transactionID) {
Transaction t = super.w.getTransaction(super.principal, transactionID);
if (t instanceof AddItemTransaction) {
AddItemTransaction ait = (AddItemTransaction) t;
if (t instanceof StockTransaction
&& ait.getCategory() == Transaction.Category.ISSUE_STOCK
&& ait.getType() == -1) {
// If it is a change in the total number of shares issued.
StockTransaction ist = (StockTransaction) t;
totalShares += ist.getQuantity();
} else if (t instanceof StockTransaction
&& ait.getCategory() == Transaction.Category.TRANSFER_STOCK
) {
//
stockInRRs[ait.getType()] += ait.getQuantity();
} else if (t instanceof BondTransaction) {
bonds += ait.getQuantity();
}
} else {
super.incrementRunningTotal(transactionID);
}
}
@Override
protected void setTotalsArrayLength(int length) {
// TODO Auto-generated method stub
super.setTotalsArrayLength(length);
}
@Override
protected void storeRunningTotal(int timeIndex) {
// TODO Auto-generated method stub
super.storeRunningTotal(timeIndex);
}
public FinancialDataGatherer(ReadOnlyWorld w, FreerailsPrincipal principal) {
super(w, principal);
stockInRRs = new int [w.getNumberOfPlayers()];
calculateValues();
this.playerID = w.getID(principal);
}
public void changeTreasuryStock(int deltaStock) {
}
public void changeStake(int stakeHolder, int deltaStock) {
}
public boolean canIssueBond() {
return nextBondInterestRate() <= 7;
}
public boolean canBuyStock() {
return totalShares > 0;
}
public int nextBondInterestRate() {
EconomicClimate ec = (EconomicClimate) w.get(ITEM.ECONOMIC_CLIMATE);
return bonds + ec.getBaseInterestRate();
}
public int[] bondInterestRates() {
return null;
}
/** Returns the number of stock in the Treasury */
public int treasuryStock() {
return stockInRRs[playerID];
}
/** Returns The number of open Shares */
public int totalShares() {
return totalShares;
}
public int sharesHeldByPublic(){
int[]stock = getStockInThisRRs();
int returnValue = this.totalShares;
for (int i = 0; i < stock.length; i++) {
returnValue -= stock[i];
}
return returnValue;
}
public boolean thisRRHasStakeIn(int otherReId){
return stockInRRs[otherReId] > 0;
}
public Money netWorth() {
NetWorthCalculator nwc = new NetWorthCalculator(w, principal);
GameTime[] times = {GameTime.BIG_BANG, GameTime.END_OF_THE_WORLD};
nwc.setTimes(times);
return nwc.calculateValue();
}
@Override
protected boolean condition(int transactionID) {
// We'll do the work when incrementRunningTotal gets called.
return true;
}
public int[] getStockInThisRRs() {
if(null == stockInThisRRs){
stockInThisRRs = new int[w.getNumberOfPlayers()];
for(int i = 0; i < w.getNumberOfPlayers(); i++){
Player p = w.getPlayer(i);
FinancialDataGatherer temp = new FinancialDataGatherer(w, p.getPrincipal());
stockInThisRRs[i] = temp.stockInRRs[this.playerID];
}
}
return stockInThisRRs;
}
public int[] getStockInRRs() {
return stockInRRs;
}
public int getBonds() {
return bonds;
}
}

/**
* Not yet implemented
*
* @author Luke
*
*/
public class FinancialMoveProducer {
public static final Money IPO_SHARE_PRICE = new Money(5);
public static final int SHARE_BUNDLE_SIZE = 10000;
public static final int IPO_SIZE = SHARE_BUNDLE_SIZE * 10;
FinancialMoveProducer(ReadOnlyWorld row) {
}
EconomicClimate worsen() {
return null;
}
EconomicClimate improve() {
return null;
}
}

/**
* GraphExplorer that explorers track, the ints it returns are encoded
* PositionOnTrack objects.
*
* @author Luke
*/
public class FlatTrackExplorer implements GraphExplorer, Serializable {
private static final long serialVersionUID = 3834311713465185081L;
private PositionOnTrack currentPosition = PositionOnTrack.createComingFrom(
0, 0, Step.NORTH);
final PositionOnTrack currentBranch = PositionOnTrack.createComingFrom(0,
0, Step.NORTH);
private boolean beforeFirst = true;
private final ReadOnlyWorld w;
public ReadOnlyWorld getWorld() {
return w;
}
public void setPosition(int i) {
beforeFirst = true;
currentPosition.setValuesFromInt(i);
}
public int getPosition() {
return this.currentPosition.toInt();
}
public void moveForward() {
if (beforeFirst) {
throw new IllegalStateException();
}
this.setPosition(this.getVertexConnectedByEdge());
}
public void nextEdge() {
if (!hasNextEdge()) {
throw new NoSuchElementException();
}
Step v = this.getFirstVectorToTry();
Point p = new Point(currentPosition.getX(), currentPosition.getY());
FreerailsTile ft = (FreerailsTile)w.getTile(p.x, p.y);
TrackPiece tp = ft.getTrackPiece();
TrackConfiguration conf = tp.getTrackConfiguration();
Step[] vectors = Step.getList();
int i = v.getID();
int loopCounter = 0;
while (!conf.contains(vectors[i].get9bitTemplate())) {
i++;
i = i % 8;
loopCounter++;
if (8 < loopCounter) {
throw new IllegalStateException();
// This should never happen.. ..but it does happen when you
// removed the track from under a train.
}
}
Step branchDirection = Step.getInstance(i);
this.currentBranch.setCameFrom(branchDirection);
int x = this.currentPosition.getX() + branchDirection.deltaX;
int y = this.currentPosition.getY() + branchDirection.deltaY;
this.currentBranch.setX(x);
this.currentBranch.setY(y);
beforeFirst = false;
}
public int getVertexConnectedByEdge() {
return currentBranch.toInt();
}
public int getEdgeCost() {
return (int) Math.round(currentBranch.cameFrom().getLength());
}
public boolean hasNextEdge() {
if (beforeFirst) {
// We can always go back the way we have come, so if we are before
// the first
// branch, there must be a branch: the one we used to get here.
return true;
}
// Since we can always go back the way we have come, if the direction of
// current branch is not equal to the opposite of the current direction,
// there must be another branch.
Step currentBranchDirection = this.currentBranch.cameFrom();
Step oppositeToCurrentDirection = this.currentPosition.cameFrom()
.getOpposite();
if (oppositeToCurrentDirection.getID() == currentBranchDirection
.getID()) {
return false;
}
return true;
}
public FlatTrackExplorer(ReadOnlyWorld world, PositionOnTrack p) {
w = world;
FreerailsTile tile = (FreerailsTile) world.getTile(p.getX(), p.getY());
if (tile.getTrackPiece().getTrackTypeID() == NullTrackType.NULL_TRACK_TYPE_RULE_NUMBER) {
throw new IllegalArgumentException(p.toString());
}
this.currentPosition = PositionOnTrack.createComingFrom(p.getX(), p
.getY(), p.cameFrom());
}
/**
* @return an array of PositionOnTrack objects describing the set of
* possible orientations at this position (heading towards the
* center of the tile)
* @param p
* location of track to consider.
*/
public static PositionOnTrack[] getPossiblePositions(ReadOnlyWorld w,
ImPoint p) {
TrackPiece tp = ((FreerailsTile) w.getTile(p.x, p.y)).getTrackPiece();
TrackConfiguration conf = tp.getTrackConfiguration();
Step[] vectors = Step.getList();
// Count the number of possible positions.
int n = 0;
for (int i = 0; i < vectors.length; i++) {
if (conf.contains(vectors[i].get9bitTemplate())) {
n++;
}
}
PositionOnTrack[] possiblePositions = new PositionOnTrack[n];
n = 0;
for (int i = 0; i < vectors.length; i++) {
if (conf.contains(vectors[i].get9bitTemplate())) {
possiblePositions[n] = PositionOnTrack.createComingFrom(p.x,
p.y, vectors[i].getOpposite());
n++;
}
}
return possiblePositions;
}
Step getFirstVectorToTry() {
if (beforeFirst) {
// Return the vector that is 45 degrees clockwise from the opposite
// of the current position.
Step v = this.currentPosition.cameFrom();
v = v.getOpposite();
int i = v.getID();
i++;
i = i % 8;
v = Step.getInstance(i);
return v;
}
// Return the vector that is 45 degrees clockwise from the direction
// of the current branch.
Step v = this.currentBranch.cameFrom();
int i = v.getID();
i++;
i = i % 8;
v = Step.getInstance(i);
return v;
}
public int getH() {
// TODO Auto-generated method stub
return 0;
}
}

/**
* Tags classes that the server may need to save but which won't be sent to
* clients.
*
* @author Luke Lindsay
*
*/
public interface FreerailsServerSerializable extends Serializable {
}

/**
* This interface lets the caller explorer a graph while hiding the way the
* graph is stored. Vertices are packed into single ints to avoid the cost of
* object creation and garbage collection.
*
* 24-Nov-2002
*
* @author Luke Lindsay
*/
public interface GraphExplorer {
void setPosition(int vertex);
/** Return the current edge. */
int getPosition();
/**
* Sets the current edge to the current vertex's next edge. Throws a
* NoSuchElementException if the vertex does not have another edge.
*/
void nextEdge();
/**
* Returns the vertex that is connected to the current vertex by the current
* edge.
*/
int getVertexConnectedByEdge();
/** Returns the cost of the current edge. */
int getEdgeCost();
boolean hasNextEdge();
/**
* Moves this GraphExplorer from the current vertex to the vertex that is
* connected to the current vertex by the current edge.
*/
void moveForward();
int getH();
}

/**
* Defines part of the contract for a pathfinder whose search can be completed
* in several steps.
*
* @author Luke
*
*/
public interface IncrementalPathFinder {
// TODO replace with enum.
public static final int PATH_NOT_FOUND = Integer.MIN_VALUE;
public final int PATH_FOUND = Integer.MIN_VALUE + 1;
public static final int SEARCH_PAUSED = Integer.MIN_VALUE + 2;
public static final int SEARCH_NOT_STARTED = Integer.MIN_VALUE + 3;
public abstract int getStatus();
public abstract void search(long maxDuration) throws PathNotFoundException;
public abstract void abandonSearch();
}

/**
* Since there is no setMinimum size method on JFrame, we use an instance of
* this class to do the job.
*
* @author Luke
*
*/
public class JFrameMinimumSizeEnforcer implements ComponentListener {
private final int minWidth;
private final int minHeight;
public JFrameMinimumSizeEnforcer(int w, int h) {
this.minHeight = h;
this.minWidth = w;
}
public void componentResized(ComponentEvent arg0) {
Component c = arg0.getComponent();
int width = c.getWidth();
int height = c.getHeight();
// we check if either the width
// or the height are below minimum
boolean resize = false;
if (width < minWidth) {
resize = true;
width = minWidth;
}
if (height < minHeight) {
resize = true;
height = minHeight;
}
if (resize) {
c.setSize(width, height);
}
}
public void componentMoved(ComponentEvent arg0) {
}
public void componentShown(ComponentEvent arg0) {
}
public void componentHidden(ComponentEvent arg0) {
}
}

class Map implements GraphExplorer {
// Look at SimpleAStarPathFinderTest.svg to see it
private final Node[] nodes = new Node[] {
new Node(new int[] { 1 }, new int[] { 11 }), // 0
new Node(new int[] { 0, 5, 2 }, new int[] { 11, 4, 8 }), // 1 //
// try
// {11,4,4}
new Node(new int[] { 5, 3, 4, 1 }, new int[] { 5, 10, 12, 8 }), // 2
// //try{5,10,12,4}
new Node(new int[] { 2 }, new int[] { 10 }), // 3
new Node(new int[] { 5, 2 }, new int[] { 18, 12 }), // 4
new Node(new int[] { 1, 6, 4, 2 }, new int[] { 4, 3, 18, 5 }), // 5
new Node(new int[] { 5, 7 }, new int[] { 3, 4 }), // 6
new Node(new int[] { 6 }, new int[] { 4 }), // 7
};
private int position = 0;
private int branch = -1;
public void setPosition(int i) {
this.position = i;
this.branch = -1;
}
public int getPosition() {
return this.position;
}
public void nextEdge() {
if (hasNextEdge()) {
branch++;
} else {
throw new NoSuchElementException();
}
}
public int getVertexConnectedByEdge() {
return nodes[position].edges[branch];
}
public int getEdgeCost() {
return nodes[position].distances[branch];
}
public boolean hasNextEdge() {
if (nodes[position].edges.length > (branch + 1)) {
return true;
}
return false;
}
public void moveForward() {
this.setPosition(this.getVertexConnectedByEdge());
}
public int getH() {
// TODO Auto-generated method stub
return 0;
}
}

/**
* Defines a command sent from the server to the client.
*
* @author Luke
*
*/
public interface Message2Client extends FreerailsSerializable {
/** Executes this command on the specified ClientControlInterface. */
MessageStatus execute(ClientControlInterface client);
/** Returns the id of this command. */
int getID();
}

/**
* Defines a command sent from a client to the server.
*
* @author Luke
*
*/
public interface Message2Server extends FreerailsSerializable {
int getID();
MessageStatus execute(ServerControlInterface server);
}

/**
* An instance of this class is returned to the client (the server) when a
* Message2Server (Message2Client) is executed by the server (the client).
*
* @see Message2Client
* @see Message2Server
* @author Luke
*
*/
public class MessageStatus implements FreerailsSerializable {
private static final long serialVersionUID = 3257285842216103987L;
private final int id;
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (!(o instanceof MessageStatus))
return false;
final MessageStatus messageStatus = (MessageStatus) o;
if (id != messageStatus.id)
return false;
if (successful != messageStatus.successful)
return false;
if (reason != null ? !reason.equals(messageStatus.reason)
: messageStatus.reason != null)
return false;
return true;
}
@Override
public int hashCode() {
int result;
result = id;
result = 29 * result + (reason != null ? reason.hashCode() : 0);
result = 29 * result + (successful ? 1 : 0);
return result;
}
private final String reason;
private final boolean successful;
public MessageStatus(int id, boolean successful, String reason) {
this.id = id;
this.reason = reason;
this.successful = successful;
}
public MessageStatus(int id, boolean successful) {
this.id = id;
this.reason = null;
this.successful = successful;
}
/** Returns the id of the command whose status this object stores. */
public int getId() {
return id;
}
/** Returns the reason the command failed, may be null. */
public String getReason() {
return reason;
}
/** True if the command was successfully executed. */
public boolean isSuccessful() {
return successful;
}
}

/**
* Defines methods and constants that GUI classes can use to access shared data.
*
* @author Luke
*
*/
public interface ModelRoot extends MoveExecutor {
public enum Property {
CURSOR_POSITION, CURSOR_MODE, TRACK_BUILDER_MODE, PREVIOUS_CURSOR_MODE, CURSOR_MESSAGE, QUICK_MESSAGE, PERMANENT_MESSAGE, SHOW_STATION_NAMES, SHOW_CARGO_AT_STATIONS, SHOW_STATION_BORDERS, SERVER, PLAY_SOUNDS, BUILD_TRACK_STRATEGY, IGNORE_KEY_EVENTS, PROPOSED_TRACK, SAVED_GAMES_LIST, THINKING_POINT, TIME, SELECTED_TRAIN
}
public enum Value {
PLACE_STATION_CURSOR_MODE, BUILD_TRACK_CURSOR_MODE
}
void sendCommand(Message2Server c);
void setProperty(Property property, Object newValue);
/**
* Tests whether the specified property has the specified value.
*/
boolean is(Property property, Object value);
Object getProperty(Property property);
}

/**
* Lets the caller try and execute Moves.
*
* @author Luke
*
*/
public interface MoveExecutor {
MoveStatus doMove(Move m);
MoveStatus doPreMove(PreMove pm);
MoveStatus tryDoMove(Move m);
ReadOnlyWorld getWorld();
FreerailsPrincipal getPrincipal();
}

/**
* Generates moves for changes in train position and stops at stations.
*
* @author Luke
*
*/
public class MoveTrainPreMove implements PreMove {
private static final long serialVersionUID = 3545516188269491250L;
private static final Logger logger = Logger.getLogger(MoveTrainPreMove.class
.getName());
/** Uses static method to make testing easier.*/
public static Step findNextStep(ReadOnlyWorld world,
PositionOnTrack currentPosition, ImPoint target) {
PathOnTrackFinder pathFinder = new PathOnTrackFinder(world);
try {
ImPoint location = new ImPoint(currentPosition.getX(),
currentPosition.getY());
pathFinder.setupSearch(location, target);
pathFinder.search(-1);
return pathFinder.pathAsVectors()[0];
} catch (PathNotFoundException e) {
// The pathfinder couldn't find a path so we
// go in any legal direction.
FlatTrackExplorer explorer = new FlatTrackExplorer(world,
currentPosition);
explorer.nextEdge();
int next = explorer.getVertexConnectedByEdge();
PositionOnTrack nextPosition = new PositionOnTrack(next);
return nextPosition.cameFrom();
}
}
private final FreerailsPrincipal principal;
private final int trainID;
public MoveTrainPreMove(int id, FreerailsPrincipal p) {
trainID = id;
principal = p;
}
double acceleration(int wagons) {
return 0.5d/(wagons + 1);
}
/**
* Returns true iff an updated is due.
*
*/
public boolean isUpdateDue(ReadOnlyWorld w) {
GameTime currentTime = w.currentTime();
TrainAccessor ta = new TrainAccessor(w, principal, trainID);
ActivityIterator ai = w.getActivities(principal, trainID);
ai.gotoLastActivity();
double finishTime = ai.getFinishTime();
double ticks = currentTime.getTicks();
boolean hasFinishedLastActivity = Math.floor(finishTime) <= ticks;
TrainActivity trainActivity = ta.getStatus(finishTime);
if(trainActivity == TrainActivity.WAITING_FOR_FULL_LOAD){
//Check whether there is any cargo that can be added to the train.
ImInts spaceAvailable = ta.spaceAvailable();
int stationId = ta.getStationId(ticks);
if(stationId == -1)
throw new IllegalStateException();
StationModel station = (StationModel)w.get(principal, KEY.STATIONS, stationId);
CargoBundle cb = (CargoBundle)w.get(principal, KEY.CARGO_BUNDLES, station.getCargoBundleID());
for(int i = 0; i < spaceAvailable.size(); i++){
int space = spaceAvailable.get(i);
int atStation = cb.getAmount(i);
if(space * atStation > 0){
logger.fine("There is cargo to transfer!");
return true;
}
}
return !ta.keepWaiting();
}
return hasFinishedLastActivity;
}
private ImPoint currentTrainTarget(ReadOnlyWorld w) {
TrainAccessor ta = new TrainAccessor(w, principal, trainID);
return ta.getTarget();
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (!(o instanceof MoveTrainPreMove))
return false;
final MoveTrainPreMove moveTrainPreMove = (MoveTrainPreMove) o;
if (trainID != moveTrainPreMove.trainID)
return false;
if (!principal.equals(moveTrainPreMove.principal))
return false;
return true;
}
public Move generateMove(ReadOnlyWorld w) {
// Check that we can generate a move.
if (!isUpdateDue(w))
throw new IllegalStateException();
TrainAccessor ta = new TrainAccessor(w, principal, trainID);
TrainMotion tm = ta.findCurrentMotion(Double.MAX_VALUE);
SpeedTimeAndStatus.TrainActivity activity = tm.getActivity();
switch (activity) {
case STOPPED_AT_STATION:
return moveTrain(w);
case READY:
{
// Are we at a station?
TrainStopsHandler stopsHandler = new TrainStopsHandler(trainID,
principal, new WorldDiffs(w));
ta.getStationId(Integer.MAX_VALUE);
PositionOnTrack pot = tm.getFinalPosition();
int x = pot.getX();
int y = pot.getY();
boolean atStation = stopsHandler.getStationID(x, y) >= 0;
TrainMotion nextMotion;
if (atStation) {
// We have just arrived at a station.
double durationOfStationStop = 10;
stopsHandler.arrivesAtPoint(x, y);
SpeedTimeAndStatus.TrainActivity status = stopsHandler.isWaiting4FullLoad() ? WAITING_FOR_FULL_LOAD : STOPPED_AT_STATION;
PathOnTiles path = tm.getPath();
int lastTrainLength = tm.getTrainLength();
int currentTrainLength = stopsHandler.getTrainLength();
//If we are adding wagons we may need to lengthen the path.
if(lastTrainLength < currentTrainLength){
path = TrainStopsHandler.lengthenPath(w, path, currentTrainLength);
}
nextMotion = new TrainMotion(path, currentTrainLength,
durationOfStationStop, status);
// Create a new Move object.
Move trainMove = new NextActivityMove(nextMotion, trainID,
principal);
Move cargoMove = stopsHandler.getMoves();
return new CompositeMove(trainMove, cargoMove);
}
return moveTrain(w);
}
case WAITING_FOR_FULL_LOAD:
{
TrainStopsHandler stopsHandler = new TrainStopsHandler(trainID,
principal, new WorldDiffs(w));
boolean waiting4fullLoad = stopsHandler.refreshWaitingForFullLoad();
Move cargoMove = stopsHandler.getMoves();
if(!waiting4fullLoad){
Move trainMove = moveTrain(w);
if(null != trainMove){
return new CompositeMove(trainMove, cargoMove);
}else{
return cargoMove;
}
}
stopsHandler.makeTrainWait(30);
return cargoMove;
}
default:
throw new UnsupportedOperationException(activity.toString());
}
}
public SpeedTimeAndStatus.TrainActivity getActivity(ReadOnlyWorld w){
TrainAccessor ta = new TrainAccessor(w, principal, trainID);
TrainMotion tm = ta.findCurrentMotion(Integer.MAX_VALUE);
return tm.getActivity();
}
@Override
public int hashCode() {
int result;
result = trainID;
result = 29 * result + principal.hashCode();
return result;
}
private TrainMotion lastMotion(ReadOnlyWorld w) {
ActivityIterator ai = w.getActivities(principal, trainID);
ai.gotoLastActivity();
TrainMotion lastMotion = (TrainMotion) ai.getActivity();
return lastMotion;
}
private Move moveTrain(ReadOnlyWorld w) {
// Find the next vector.
Step nextVector = nextStep(w);
HashMap<TrackSection, Integer> occupiedTrackSections = occupiedTrackSections(w);
TrainMotion motion = lastMotion(w);
PositionOnTrack pot = motion.getFinalPosition();
ImPoint tile = new ImPoint(pot.getX(), pot.getY());
TrackSection desiredTrackSection = new TrackSection(nextVector, tile);
// Check whether the desired track section is single or double track.
ImPoint tileA = desiredTrackSection.tileA();
ImPoint tileB = desiredTrackSection.tileB();
FreerailsTile fta = (FreerailsTile) w.getTile(tileA.x, tileA.y);
FreerailsTile ftb = (FreerailsTile) w.getTile(tileB.x, tileB.y);
TrackPiece tpa = fta.getTrackPiece();
TrackPiece tpb = ftb.getTrackPiece();
int tracks = 1;
if (tpa.getTrackRule().isDouble() && tpb.getTrackRule().isDouble()) {
tracks = 2;
}
if (occupiedTrackSections.containsKey(desiredTrackSection)) {
int trains = occupiedTrackSections.get(desiredTrackSection);
if (trains >= tracks) {
// We need to wait for the track ahead to clear.
return stopTrain(w);
}
}
// Create a new train motion object.
TrainMotion nextMotion = nextMotion(w, nextVector);
return new NextActivityMove(nextMotion, trainID, principal);
}
private HashMap<TrackSection, Integer> occupiedTrackSections(ReadOnlyWorld w) {
HashMap<TrackSection, Integer> occupiedTrackSections = new HashMap<TrackSection, Integer>();
for (int i = 0; i < w.size(principal, KEY.TRAINS); i++) {
TrainModel train = (TrainModel) w.get(principal,
KEY.TRAINS, i);
if (null == train)
continue;
TrainAccessor ta = new TrainAccessor(w, principal, i);
GameTime gt = w.currentTime();
if(ta.isMoving(gt.getTicks())){
HashSet<TrackSection> sections = ta.occupiedTrackSection(gt.getTicks());
for (TrackSection section : sections) {
if(occupiedTrackSections.containsKey(section)){
int count = occupiedTrackSections.get(section);
count++;
occupiedTrackSections.put(section, count);
}else{
occupiedTrackSections.put(section, 1);
}
}
}
}
return occupiedTrackSections;
}
TrainMotion nextMotion(ReadOnlyWorld w, Step v) {
TrainMotion motion = lastMotion(w);
SpeedAgainstTime speeds = nextSpeeds(w, v);
PathOnTiles currentTiles = motion.getTiles(motion.duration());
PathOnTiles pathOnTiles = currentTiles.addSteps(v);
return new TrainMotion(pathOnTiles, currentTiles.steps(), motion
.getTrainLength(), speeds);
}
SpeedAgainstTime nextSpeeds(ReadOnlyWorld w, Step v) {
TrainAccessor ta = new TrainAccessor(w, principal, trainID);
TrainMotion lastMotion = lastMotion(w);
double u = lastMotion.getSpeedAtEnd();
double s = v.getLength();
int wagons = ta.getTrain().getNumberOfWagons();
double a0 = acceleration(wagons);
double topSpeed = topSpeed(wagons);
SpeedAgainstTime newSpeeds;
if (u < topSpeed) {
double t = (topSpeed - u) / a0;
SpeedAgainstTime a = ConstAcc.uat(u, a0, t);
t = s / topSpeed + 1; // Slightly overestimate the time
SpeedAgainstTime b = ConstAcc.uat(topSpeed, 0, t);
newSpeeds = new CompositeSpeedAgainstTime(a, b);
} else {
double t;
t = s / topSpeed + 1; // Slightly overestimate the time
newSpeeds = ConstAcc.uat(topSpeed, 0, t);
}
return newSpeeds;
}
Step nextStep(ReadOnlyWorld w) {
// Find current position.
TrainMotion currentMotion = lastMotion(w);
PositionOnTrack currentPosition = currentMotion.getFinalPosition();
// Find targets
ImPoint targetPoint = currentTrainTarget(w);
return findNextStep(w, currentPosition, targetPoint);
}
public Move stopTrain(ReadOnlyWorld w) {
TrainMotion motion = lastMotion(w);
SpeedAgainstTime stopped = ConstAcc.STOPPED;
double duration = motion.duration();
int trainLength = motion.getTrainLength();
PathOnTiles tiles = motion.getTiles(duration);
int engineDist = tiles.steps();
TrainMotion nextMotion = new TrainMotion(tiles, engineDist,
trainLength, stopped);
return new NextActivityMove(nextMotion, trainID, principal);
}
double topSpeed(int wagons) {
return 10 / (wagons + 1);
}
}

/**
* Stores a DisplayMode and provides a customised implementation of toString
* that can be used in menus.
*
* @author Luke Lindsay
*/
public class MyDisplayMode {
public final DisplayMode displayMode;
public MyDisplayMode(DisplayMode displayMode) {
this.displayMode = displayMode;
}
@Override
public String toString() {
return displayMode.getWidth() + "x" + displayMode.getHeight() + " "
+ displayMode.getBitDepth() + " bit "
+ displayMode.getRefreshRate() + "Hz";
}
@Override
public int hashCode() {
return displayMode.hashCode();
}
@Override
public boolean equals(Object o) {
if (o instanceof MyDisplayMode) {
MyDisplayMode test = (MyDisplayMode) o;
return test.displayMode.equals(this.displayMode);
}
return false;
}
}

/**
* A TransactionAggregator that calculates the networth of a player by
* totalling the value of their assets.
*
* @author Luke
*
*/
public class NetWorthCalculator extends TransactionAggregator {
public NetWorthCalculator(ReadOnlyWorld w, FreerailsPrincipal principal) {
super(w, principal);
}
@Override
protected boolean condition(int transactionID) {
Transaction t = super.w.getTransaction(super.principal,
transactionID);
if (t instanceof AddItemTransaction) {
if(t.getCategory().equals(Transaction.Category.ISSUE_STOCK)){
return true;
}
// Since buying something is just converting one asset type to
// another.
return false;
}
return true;
}
}

class Node {
int[] edges;
int[] distances;
Node(int[] e, int[] d) {
if (e.length != d.length) {
throw new IllegalArgumentException("e.length=" + e.length
+ ", e.length=" + e.length);
}
edges = e;
distances = d;
}
}

/**
* An OpenList for SimpleAStarPathFinder.
*
* @author Luke
*
*/
class OpenList implements Serializable {
private static final long serialVersionUID = 3257282539419611442L;
static class OpenListEntry implements Comparable<OpenListEntry>,
Serializable {
private static final long serialVersionUID = -4873508719707382681L;
final int f;
final int node;
OpenListEntry(int _f, int _node) {
this.f = _f;
this.node = _node;
}
public int compareTo(OpenListEntry o) {
// XXX Work around for JDK Bug ID: 6207984
if (f == o.f) {
return node - o.node;
}
return f - o.f;
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (!(o instanceof OpenListEntry))
return false;
final OpenListEntry openListEntry = (OpenListEntry) o;
if (f != openListEntry.f)
return false;
if (node != openListEntry.node)
return false;
return true;
}
@Override
public int hashCode() {
int result;
result = f;
result = 29 * result + node;
return result;
}
@Override
public String toString() {
return "OpenListEntry{node=" + node + ", f=" + f + "}";
}
}
private HashMap<Integer, OpenListEntry> map = new HashMap<Integer, OpenListEntry>();
private PriorityQueue<OpenListEntry> queue = new PriorityQueue<OpenListEntry>();
public OpenList() {
}
void clear() {
queue.clear();
map.clear();
}
int getF(int node) {
int f = map.get(node).f;
return f;
}
void add(int node, int f) {
if (map.containsKey(node)) {
OpenListEntry old = map.get(node);
queue.remove(old);
map.remove(node);
}
OpenList.OpenListEntry entry = new OpenListEntry(f, node);
queue.offer(entry);
map.put(node, entry);
}
boolean contains(int node) {
boolean containsKey = map.containsKey(node);
return containsKey;
}
int smallestF() {
OpenListEntry entry = queue.peek();
return entry.f;
}
int popNodeWithSmallestF() {
OpenListEntry entry = queue.remove();
int node = entry.node;
OpenListEntry removed = map.remove(node);
if (null == removed) {
System.out.println("Shizer, size =" + queue.size());
}
return node;
}
int size() {
return queue.size();
}
}

/**
* Thrown when a path cannot be found.
*
* @author Luke
*
*/
public class PathNotFoundException extends Exception {
private static final long serialVersionUID = 4121409601112717368L;
public PathNotFoundException(String arg0) {
super(arg0);
}
}

/**
* Finds a path along existing track. Used for upgrading or removing track
* between two points on the track.
*
* @author Luke
*
*/
public class PathOnTrackFinder implements IncrementalPathFinder {
private static final Logger logger = Logger
.getLogger(IncrementalPathFinder.class.getName());
private SimpleAStarPathFinder pathFinder = new SimpleAStarPathFinder();
private ImPoint startPoint;
private final ReadOnlyWorld world;
public PathOnTrackFinder(ReadOnlyWorld world) {
this.world = world;
}
public void abandonSearch() {
pathFinder.abandonSearch();
}
public int getStatus() {
return pathFinder.getStatus();
}
public Step[] pathAsVectors() {
int[] pathAsInts = pathFinder.retrievePath().toArray();
Step[] vectors = new Step[pathAsInts.length];
int x = startPoint.x;
int y = startPoint.y;
for (int i = 0; i < pathAsInts.length; i++) {
PositionOnTrack p2 = new PositionOnTrack(pathAsInts[i]);
vectors[i] = Step.getInstance(p2.getX() - x, p2.getY() - y);
x = p2.getX();
y = p2.getY();
}
return vectors;
}
public void search(long maxDuration) throws PathNotFoundException {
pathFinder.search(maxDuration);
}
public void setupSearch(ImPoint from, ImPoint target) throws PathNotFoundException {
startPoint = from;
logger
.fine("Find track path from " + from + " to "
+ target);
/* Check there is track at both the points. */
FreerailsTile tileA = (FreerailsTile) world.getTile(from.x,
from.y);
FreerailsTile tileB = (FreerailsTile) world.getTile(target.x,
target.y);
if (!tileA.hasTrack()) {
throw new PathNotFoundException("No track at " + from.x
+ ", " + from.y + ".");
}
if (!tileB.hasTrack()) {
throw new PathNotFoundException("No track at " + target.x
+ ", " + target.y + ".");
}
PositionOnTrack[] startPoints = FlatTrackExplorer.getPossiblePositions(
world, from);
PositionOnTrack[] targetPoints = FlatTrackExplorer
.getPossiblePositions(world, target);
FlatTrackExplorer explorer = new FlatTrackExplorer(world,
startPoints[0]);
pathFinder.setupSearch(PositionOnTrack.toInts(startPoints),
PositionOnTrack.toInts(targetPoints), explorer);
}
}

/**
* Defines a method that generates a move based on the state of the world
* object. The state of a move is often a function of the state of the world
* object and some other input.
*
* @author Luke
*
*/
public interface PreMove extends FreerailsSerializable {
Move generateMove(ReadOnlyWorld w);
}

/**
* Records the success or failure of an attempt to execute a move.
*
* @author lindsal
*/
final public class PreMoveStatus implements FreerailsSerializable {
private static final long serialVersionUID = 3978145456646009140L;
public static final PreMoveStatus PRE_MOVE_OK = new PreMoveStatus(
MoveStatus.MOVE_OK);
public final MoveStatus ms;
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (!(o instanceof PreMoveStatus))
return false;
final PreMoveStatus preMoveStatus = (PreMoveStatus) o;
if (!ms.equals(preMoveStatus.ms))
return false;
return true;
}
@Override
public int hashCode() {
return ms.hashCode();
}
/**
* Avoid creating a duplicate when deserializing.
*/
private Object readResolve() {
if (ms.ok) {
return PRE_MOVE_OK;
}
return this;
}
private PreMoveStatus(MoveStatus ms) {
this.ms = ms;
}
public static PreMoveStatus failed(String reason) {
return new PreMoveStatus(MoveStatus.moveFailed(reason));
}
public static PreMoveStatus fromMoveStatus(MoveStatus ms) {
if (ms.ok) {
return PRE_MOVE_OK;
}
return new PreMoveStatus(ms);
}
}

/**
* This class generates Moves that pay the player for delivering the cargo.
*
* @author Luke Lindsay
*
*/
public class ProcessCargoAtStationMoveGenerator {
/**
* Determines how much the player gets for delivering cargo. Changed from
* 100 to 75 to fix bug 910132 (Too easy to make money!)
*/
private final static int MAGIC_NUMBER = 75;
public static ArrayList<Move> processCargo(ReadOnlyWorld w,
CargoBundle bundle, int stationID, FreerailsPrincipal p,
int trainId) {
StationModel thisStation = (StationModel) w.get(p,
KEY.STATIONS, stationID);
Iterator<CargoBatch> batches = bundle.cargoBatchIterator();
ArrayList<Move> moves = new ArrayList<Move>();
while (batches.hasNext()) {
CargoBatch batch = batches.next();
double distanceSquared = (batch.getSourceX() - thisStation.x)
* (batch.getSourceX() - thisStation.x)
+ (batch.getSourceY() - thisStation.y)
* (batch.getSourceY() - thisStation.y);
double dist = Math.sqrt(distanceSquared);
int quantity = bundle.getAmount(batch);
double amount = quantity * Math.log(dist) * MAGIC_NUMBER;
Money money = new Money((long) amount);
DeliverCargoReceipt receipt = new DeliverCargoReceipt(money,
quantity, stationID, batch, trainId);
moves.add(new AddTransactionMove(p, receipt));
}
return moves;
}
}

/**
* Returns a random path along the track.
*
* @author Luke Lindsay 13-Oct-2002
*
*/
public class RandomPathFinder implements FreerailsPathIterator {
private static final long serialVersionUID = 3832906571880608313L;
private final FlatTrackExplorer trackExplorer;
private final PositionOnTrack p1 = new PositionOnTrack();
private final PositionOnTrack p2 = new PositionOnTrack();
private static final int tileSize = 30;
public RandomPathFinder(FlatTrackExplorer tx) {
trackExplorer = tx;
}
public boolean hasNext() {
return trackExplorer.hasNextEdge();
}
public void nextSegment(IntLine line) {
p1.setValuesFromInt(trackExplorer.getPosition());
line.x1 = p1.getX() * tileSize + tileSize / 2;
line.y1 = p1.getY() * tileSize + tileSize / 2;
trackExplorer.nextEdge();
trackExplorer.moveForward();
p2.setValuesFromInt(trackExplorer.getPosition());
line.x2 = p2.getX() * tileSize + tileSize / 2;
line.y2 = p2.getY() * tileSize + tileSize / 2;
}
}

public class ReportBugTextGenerator {
private static final String TRACKER_URL = "http://sourceforge.net/tracker/?group_id=9495&atid=109495";
public static void main(String[] args) {
Exception e = genException();
System.out.println(genText());
System.out.println(genText(e));
}
private static Exception genException() {
Exception e = new Exception();
return e;
}
public static String genText() {
StringBuffer sb = new StringBuffer();
sb.append("How to report a bug\n");
sb.append("\n");
sb.append("Use the sourceforge.net bug tracker at the following url:\n");
sb.append(TRACKER_URL);
sb.append("\n");
sb.append("\n");
sb.append("Please include:\n");
sb.append(" 1. Steps to reproduce the bug (attach a save game if appropriate).\n");
sb.append(" 2. What you expected to see.\n");
sb.append(" 3. What you saw instead (attach a screenshot if appropriate).\n");
sb.append(" 4. The details below (copy and past them into the bug report).\n");
appendBuildProps(sb);
sb.append("\n");
sb.append("\n");
return sb.toString();
}
public static String genText(Exception e) {
StackTraceElement[] s = e.getStackTrace();
StringBuffer sb = new StringBuffer();
sb.append("Unexpected Exception\n");
sb.append("\n");
sb.append("Consider submitting a bug report using the sourceforge.net" +
" bug tracker at the following url:\n");
sb.append(TRACKER_URL);
sb.append("\n");
sb.append("\n");
sb.append("Please:\n");
sb.append(" 1. Use the following as the title of the bug report:\n\t");
sb.append(" Unexpected Exception: ");
sb.append(s[0].getFileName());
sb.append(" line ");
sb.append(s[0].getLineNumber());
sb.append("\n");
sb.append(" 2. Include steps to reproduce the bug (attach a save game if appropriate).\n");
sb.append(" 3. Copy and paste the details below into the bug report:\n");
appendBuildProps(sb);
sb.append("\n");
sb.append("\n\t");
sb.append(e.toString());
for (StackTraceElement ste : s) {
sb.append("\n\t\t at ");
sb.append(ste);
}
return sb.toString();
}
private static void appendBuildProps(StringBuffer sb) {
String version = null;
String builtBy = null;;
try {
Properties props = new Properties();
InputStream in = ReportBugTextGenerator.class
.getResourceAsStream("/build.properties");
props.load(in);
in.close();
version = props.getProperty("freerails.build");
builtBy = props.getProperty("freerails.built.by");
} catch (Exception e) {
// ignore, there's nothing useful we can do.
}
version = null == version ? "not set" : version;
builtBy = null == builtBy ? "not set" : builtBy;
sb.append("\t");
sb.append(System.getProperty("os.name"));
sb.append(" ");
sb.append(System.getProperty("os.version"));
sb.append("\n\t");
sb.append(System.getProperty("java.vm.name"));
sb.append(" ");
sb.append(System.getProperty("java.version"));
sb.append("\n\t");
sb.append("Freerails build ");
sb.append(version);
sb.append(" compiled by ");
sb.append(builtBy);
}
@SuppressWarnings("deprecation")
public static void unexpectedException(Exception e) {
ScreenHandler.exitFullScreenMode();
String str = genText(e);
System.err.print(str);
UnexpectedExceptionForm unexpectedExceptionForm = new UnexpectedExceptionForm();
unexpectedExceptionForm.setText(str);
unexpectedExceptionForm.setVisible(true);
if(!EventQueue.isDispatchThread()){
Thread.currentThread().stop();
}
}
}

/**
* Handles going into fullscreen mode and setting buffer strategy etc.
*
* @author Luke
*/
final public class ScreenHandler {
private static final Logger logger = Logger.getLogger(ScreenHandler.class
.getName());
public static final int FULL_SCREEN = 0;
public static final int WINDOWED_MODE = 1;
public static final int FIXED_SIZE_WINDOWED_MODE = 2;
public final JFrame frame;
private BufferStrategy bufferStrategy;
private DisplayMode displayMode;
private final int mode;
private boolean isInUse = false;
/** Whether the window is minimised. */
private boolean isMinimised = false;
static GraphicsDevice device = GraphicsEnvironment
.getLocalGraphicsEnvironment().getDefaultScreenDevice();
public ScreenHandler(JFrame f, int mode, DisplayMode displayMode) {
this.displayMode = displayMode;
frame = f;
this.mode = mode;
}
public ScreenHandler(JFrame f, int mode) {
frame = f;
this.mode = mode;
}
private static void goFullScreen(JFrame frame, DisplayMode displayMode) {
setRepaintOffAndDisableDoubleBuffering(frame);
/*
* We need to make the frame not displayable before calling
* setUndecorated(true) otherwise a
* java.awt.IllegalComponentStateException will get thrown.
*/
if (frame.isDisplayable()) {
frame.dispose();
}
frame.setUndecorated(true);
device.setFullScreenWindow(frame);
if (device.isDisplayChangeSupported()) {
if (null == displayMode) {
displayMode = getBestDisplayMode();
}
logger.info("Setting display mode to: "
+ (new MyDisplayMode(displayMode).toString()));
device.setDisplayMode(displayMode);
}
frame.validate();
}
public synchronized void apply() {
switch (mode) {
case FULL_SCREEN: {
goFullScreen(frame, displayMode);
break;
}
case WINDOWED_MODE: {
// Some of the dialogue boxes do not get layed out properly if they
// are smaller than their
// minimum size. JFrameMinimumSizeEnforcer increases the size of the
// Jframe when its size falls
// below the specified size.
frame.addComponentListener(new JFrameMinimumSizeEnforcer(640, 480));
frame.setSize(640, 480);
frame.setVisible(true);
break;
}
case FIXED_SIZE_WINDOWED_MODE: {
/*
* We need to make the frame not displayable before calling
* setUndecorated(true) otherwise a
* java.awt.IllegalComponentStateException will get thrown.
*/
if (frame.isDisplayable()) {
frame.dispose();
}
frame.setUndecorated(true);
frame.setResizable(false);
frame.setSize(640, 480);
frame.setVisible(true);
break;
}
default:
throw new IllegalArgumentException(String.valueOf(mode));
}
createBufferStrategy();
frame.addComponentListener(new java.awt.event.ComponentAdapter() {
@Override
public void componentResized(java.awt.event.ComponentEvent evt) {
createBufferStrategy();
}
});
frame.addWindowListener(new WindowAdapter() {
@Override
public void windowIconified(WindowEvent e) {
isMinimised = true;
}
@Override
public void windowDeiconified(WindowEvent e) {
isMinimised = false;
}
});
isInUse = true;
}
private synchronized void createBufferStrategy() {
// Use 2 backbuffers to avoid using too much VRAM.
frame.createBufferStrategy(2);
bufferStrategy = frame.getBufferStrategy();
setRepaintOffAndDisableDoubleBuffering(frame);
}
public synchronized Graphics getDrawGraphics() {
return bufferStrategy.getDrawGraphics();
}
public synchronized void swapScreens() {
if (!bufferStrategy.contentsLost()) {
bufferStrategy.show();
}
}
private static void setRepaintOffAndDisableDoubleBuffering(Component c) {
c.setIgnoreRepaint(true);
// Since we are using a buffer strategy we don't want Swing
// to double buffer any JComponents.
if (c instanceof JComponent) {
JComponent jComponent = (JComponent) c;
jComponent.setDoubleBuffered(false);
}
if (c instanceof java.awt.Container) {
Component[] children = ((Container) c).getComponents();
for (int i = 0; i < children.length; i++) {
setRepaintOffAndDisableDoubleBuffering(children[i]);
}
}
}
private static DisplayMode getBestDisplayMode() {
for (int x = 0; x < BEST_DISPLAY_MODES.length; x++) {
DisplayMode[] modes = device.getDisplayModes();
for (int i = 0; i < modes.length; i++) {
if (modes[i].getWidth() == BEST_DISPLAY_MODES[x].getWidth()
&& modes[i].getHeight() == BEST_DISPLAY_MODES[x]
.getHeight()
&& modes[i].getBitDepth() == BEST_DISPLAY_MODES[x]
.getBitDepth()) {
logger.fine("Best display mode is "
+ (new MyDisplayMode(BEST_DISPLAY_MODES[x]))
.toString());
return BEST_DISPLAY_MODES[x];
}
}
}
return null;
}
private static final DisplayMode[] BEST_DISPLAY_MODES = new DisplayMode[] {
new DisplayMode(640, 400, 8, 60),
new DisplayMode(800, 600, 16, 60),
new DisplayMode(1024, 768, 8, 60),
new DisplayMode(1024, 768, 16, 60), };
public synchronized boolean isMinimised() {
return isMinimised;
}
public synchronized boolean isInUse() {
return isInUse;
}
public synchronized static void exitFullScreenMode(){
device.setFullScreenWindow(null);
}
public boolean contentsRestored() {
return bufferStrategy.contentsRestored();
}
}

/**
* Defines the methods that a client can call on the server using a
* Message2Server.
*
* @see Message2Server
* @author Luke
*
*/
public interface ServerControlInterface {
public static final String FREERAILS_SAV = "freerails.sav";
public static final String VERSION = "CVS";
void loadgame(String saveGameName) throws IOException;
void savegame(String saveGameName);
void stopGame();
void refreshSavedGames();
void newGame(String mapName);
}

/**
* @author Luke
*
*/
public class SharePriceCalculator {
public int totalShares;
public int treasuryStock;
public int otherRRStakes;
public long profitsLastYear;
public long networth;
public long stockholderEquity;
public long calculatePrice() {
assert totalShares > 0;
assert totalShares >= treasuryStock + otherRRStakes;
assert stockholderEquity > 0;
long price;
long currentValue = networth + stockholderEquity;
long expectedIncrease = profitsLastYear * 5;
int publicOwnedShares = totalShares - treasuryStock - otherRRStakes;
price = 2 * (currentValue + expectedIncrease)
/ (2 * publicOwnedShares + otherRRStakes);
return price;
}
}

/**
* A simple A* pathfinder implementation. It uses int's to avoid the cost of
* object creation and garbage collection. 26-Nov-2002
*
* @author Luke Lindsay
*
*/
public class SimpleAStarPathFinder implements Serializable,
IncrementalPathFinder {
private static final long serialVersionUID = 3257565105200576310L;
private static final Logger logger = Logger
.getLogger(SimpleAStarPathFinder.class.getName());
private OpenList openList = new OpenList();
private final HashSet<Integer> startingPositions = new HashSet<Integer>();
private final HashMap<Integer, Integer> closedList = new HashMap<Integer, Integer>();
private final HashMap<Integer, Integer> shortestPath = new HashMap<Integer, Integer>();
private int status = SEARCH_NOT_STARTED;
/** Note, IntArray is not Serializable. */
private transient IntArray path = null;
private int bestPath;
private int bestPathF;
private GraphExplorer explorer;
private long searchStartTime = 0;
public int getStatus() {
return status;
}
public IntArray retrievePath() {
return path;
}
public int findstep(int currentPosition, int[] targets,
GraphExplorer tempExplorer) {
try {
return findpath(new int[] { currentPosition }, targets,
tempExplorer).get(0);
} catch (PathNotFoundException e) {
return PATH_NOT_FOUND;
}
}
public IntArray findpath(int[] currentPosition, int[] targets,
GraphExplorer e) throws PathNotFoundException {
logger.fine(currentPosition.length + " starting points; "
+ targets.length + " targets.");
setupSearch(currentPosition, targets, e);
search(-1);
return path;
}
public void search(long maxDuration) throws PathNotFoundException {
long iterationStartTime = 0;
boolean check4timeout = false;
if (maxDuration > 0) {
check4timeout = true;
iterationStartTime = System.currentTimeMillis();
if (searchStartTime == 0) {
searchStartTime = iterationStartTime;
}
}
int loopCounter = 0;
// while the open list is not empty
while (openList.size() > 0) {
// find the node with the least f on the open list, call it "q"
// pop q off the open list
int f = openList.smallestF();
int q = openList.popNodeWithSmallestF();
// generate q's successors.
explorer.setPosition(q);
// for each successor
while (explorer.hasNextEdge()) {
explorer.nextEdge();
int successor = explorer.getVertexConnectedByEdge();
int successorF = f + explorer.getEdgeCost();
// for now, let successor.h=0
// successor.g = q.g + distance between successor and q
// successor.h = distance from goal to successor
// successor.f = successor.g + successor.h
if (startingPositions.contains(successor)) {
// if successor is the goal, we have found a path, but not
// necessarily the shortest.
if (bestPathF > successorF) {
bestPath = q;
bestPathF = successorF;
}
}
if (openList.contains(successor)
&& openList.getF(successor) < successorF) {
// if a node with the same position as successor is in the
// OPEN list \
// which has a lower f than successor, skip this successor
continue;
} else if (closedList.containsKey(successor)
&& closedList.get(successor) < successorF) {
// if a node with the same position as successor is in the
// CLOSED list \
// which has a lower f than successor, skip this successor
continue;
} else {
// otherwise, add the node to the open list
openList.add(successor, successorF);
shortestPath.put(successor, q);
}
}
if (PATH_NOT_FOUND != bestPath) {
int SmallestFOnOpenList = openList.smallestF();
if (bestPathF <= SmallestFOnOpenList) {
// if the F value for the best path we have found so far is
// less than that of the node with the smallest F value on
// the open list, then the best path so far is the shortest
// path.
logger.fine("Path successfully found after " + loopCounter
+ " iterations.");
path.add(bestPath);
int step = bestPath;
while (shortestPath.containsKey(step)) {
step = shortestPath.get(step);
path.add(step);
}
logger.fine("Path found!");
status = PATH_FOUND;
return;
}
}
// push q on the closed list
// PositionOnTrack p = new PositionOnTrack(q);
closedList.put(q, f);
loopCounter++;
// Check whether we have been searching too long.
if (check4timeout && loopCounter % 50 == 0) {
long currentTime = System.currentTimeMillis();
long deltatime = currentTime - iterationStartTime;
if (deltatime > maxDuration) {
status = SEARCH_PAUSED;
long totalSearchTime = currentTime - searchStartTime;
throw new PathNotFoundException("No path found yet. "
+ totalSearchTime + "ms.");
}
}
}
status = PATH_NOT_FOUND;
logger.fine("No path found and open list empty after " + loopCounter
+ " iterations.");
throw new PathNotFoundException("Path not found.");
}
public void setupSearch(int[] currentPosition, int[] targets,
GraphExplorer e) throws PathNotFoundException {
abandonSearch();
explorer = e;
// put the starting nodes on the open list (you can leave its f at zero)
for (int i = 0; i < targets.length; i++) {
openList.add(targets[i], 0);
for (int j = 0; j < currentPosition.length; j++) {
if (targets[i] == currentPosition[j]) {
status = PATH_NOT_FOUND;
throw new PathNotFoundException("Already at target!");
}
}
}
for (int j = 0; j < currentPosition.length; j++) {
startingPositions.add(currentPosition[j]);
}
}
public void abandonSearch() {
path = new IntArray();
searchStartTime = 0;
bestPath = PATH_NOT_FOUND;
bestPathF = Integer.MAX_VALUE;
// initialize the open list
openList.clear();
// initialize the closed list
closedList.clear();
shortestPath.clear();
startingPositions.clear();
status = SEARCH_NOT_STARTED;
}
}

/**
* A MoveExecutor that executes moves on the world object passed to its
* constructor.
*
* @author Luke
*
*/
public class SimpleMoveExecutor implements MoveExecutor {
private final World w;
private final FreerailsPrincipal p;
public SimpleMoveExecutor(World world, int playerID) {
w = world;
Player player = w.getPlayer(playerID);
p = player.getPrincipal();
}
public MoveStatus doMove(Move m) {
return m.doMove(w, p);
}
public MoveStatus doPreMove(PreMove pm) {
Move m = pm.generateMove(w);
return m.doMove(w, p);
}
public MoveStatus tryDoMove(Move m) {
return m.tryDoMove(w, p);
}
public ReadOnlyWorld getWorld() {
return w;
}
public FreerailsPrincipal getPrincipal() {
return p;
}
}

/**
* Class to build a station at a given point, names station after nearest city.
* If that name is taken then a "Junction" or "Siding" is added to the name.
*
* @author Luke Lindsay 08-Nov-2002
*
* Updated 12th April 2003 by Scott Bennett to include nearest city names.
*
*/
public class StationBuilder {
private static final Logger logger = Logger.getLogger(StationBuilder.class
.getName());
private int ruleNumber;
private final MoveExecutor executor;
public StationBuilder(MoveExecutor executor) {
this.executor = executor;
TrackRule trackRule;
int i = -1;
ReadOnlyWorld world = executor.getWorld();
do {
i++;
trackRule = (TrackRule) world.get(SKEY.TRACK_RULES, i);
} while (!trackRule.isStation());
ruleNumber = i;
}
public MoveStatus tryBuildingStation(ImPoint p) {
ReadOnlyWorld world = executor.getWorld();
FreerailsPrincipal principal = executor.getPrincipal();
AddStationPreMove preMove = AddStationPreMove.newStation(p,
this.ruleNumber, principal);
Move m = preMove.generateMove(world);
MoveStatus ms = executor.tryDoMove(m);
return ms;
}
public MoveStatus buildStation(ImPoint p) {
// Only build a station if there is track at the specified point.
MoveStatus status = tryBuildingStation(p);
if (status.ok) {
FreerailsPrincipal principal = executor.getPrincipal();
AddStationPreMove preMove = AddStationPreMove.newStation(p,
this.ruleNumber, principal);
return executor.doPreMove(preMove);
}
logger.fine(status.message);
return status;
}
public void setStationType(int ruleNumber) {
this.ruleNumber = ruleNumber;
}
public int getTrackTypeID(String string) {
ReadOnlyWorld w = executor.getWorld();
for (int i = 0; i < w.size(SKEY.TRACK_RULES); i++) {
TrackRule r = (TrackRule) w.get(SKEY.TRACK_RULES, i);
if (string.equals(r.getTypeName())) {
return i;
}
}
throw new NoSuchElementException();
}
}

/**
* Calculates the stock price for each of the players.
* Stock price = [Net worth + 5 * profit last year] / [ shares owned by public +
0.5 shares owned by other players]
Let profit last year = 100,000 in the first year.
* @author Luke
*
*/
public class StockPriceCalculator {
public static class StockPrice{
public StockPrice(long netWorth, long profitLastyear, int publicShares, int otherRRShares){
currentPrice = calStockPrice(netWorth, profitLastyear, publicShares, otherRRShares);
sellPrice = calStockPrice(netWorth, profitLastyear, publicShares + STOCK_BUNDLE_SIZE, otherRRShares - STOCK_BUNDLE_SIZE);
buyPrice = calStockPrice(netWorth, profitLastyear, publicShares - STOCK_BUNDLE_SIZE, otherRRShares + STOCK_BUNDLE_SIZE);
treasurySellPrice = calStockPrice(netWorth, profitLastyear, publicShares + STOCK_BUNDLE_SIZE, otherRRShares);
treasuryBuyPrice = calStockPrice(netWorth, profitLastyear, publicShares - STOCK_BUNDLE_SIZE, otherRRShares);
}
public Money currentPrice;
public Money sellPrice;
public Money buyPrice;
public Money treasuryBuyPrice;
public Money treasurySellPrice;
}
private final ReadOnlyWorld w;
public StockPriceCalculator(ReadOnlyWorld w){
this.w = w;
}
public StockPrice[] calculate() {
StockPrice[] stockPrices = new StockPrice[w.getNumberOfPlayers()];
for (int playerId = 0; playerId < stockPrices.length; playerId++) {
long profitLastYear;
if(isFirstYear(playerId)){
profitLastYear = 100000;
}else{
profitLastYear = profitsLastYear(playerId);
}
long netWorth = netWorth(playerId);
int publicShares = sharesOwnedByPublic(playerId);
int otherRRShares = sharesOwnedByOtherPlayers(playerId);
stockPrices[playerId] = new StockPrice(netWorth, profitLastYear, publicShares, otherRRShares);
}
return stockPrices;
}
/** Returns true if the current time in the same year as the first transaction for the
* specified player.
*/
boolean isFirstYear(int playerId){
FreerailsPrincipal pr = w.getPlayer(playerId).getPrincipal();
GameTime firstTransactionTime = w.getTransactionTimeStamp(pr, 0);
GameCalendar calendar = (GameCalendar)w.get(ITEM.CALENDAR);
int year = calendar.getYear(firstTransactionTime.getTicks());
GameTime currentTime = w.currentTime();
int currentYear = calendar.getYear(currentTime.getTicks());
return year == currentYear;
}
/** Returns the players networth at the start of this year.*/
long netWorth(int playerId){
FreerailsPrincipal pr = w.getPlayer(playerId).getPrincipal();
NetWorthCalculator nwc = new NetWorthCalculator(w, pr);
//Set the interval to beginning of time to start of this year.
GameCalendar calendar = (GameCalendar)w.get(ITEM.CALENDAR);
GameTime currentTime = w.currentTime();
int currentYear = calendar.getYear(currentTime.getTicks());
int ticksAtStartOfyear = calendar.getTicks(currentYear);
GameTime[] times = {GameTime.BIG_BANG, new GameTime(ticksAtStartOfyear + 1)};
nwc.setTimes(times);
return nwc.calculateValue().getAmount();
}
long profitsLastYear(int playerId){
FreerailsPrincipal pr = w.getPlayer(playerId).getPrincipal();
GameCalendar calendar = (GameCalendar)w.get(ITEM.CALENDAR);
GameTime currentTime = w.currentTime();
int currentYear = calendar.getYear(currentTime.getTicks());
int lastyear = currentYear - 1;
int ticksAtStartOfyear = calendar.getTicks(currentYear);
int ticksAtStartOfLastYear = calendar.getTicks(lastyear);
GameTime[] interval = {new GameTime(ticksAtStartOfLastYear), new GameTime(ticksAtStartOfyear)};
TransactionAggregator aggregator = new TransactionAggregator(w, pr){
@Override
protected boolean condition(int transactionID) {
Transaction t = super.w.getTransaction(super.principal,
transactionID);
if (t instanceof AddItemTransaction) {
// Since buying something is just converting one asset type to
// another.
return false;
}
return true;
}
};
aggregator.setTimes(interval);
return aggregator.calculateValue().getAmount();
}
int sharesOwnedByPublic(int playerId){
FreerailsPrincipal pr = w.getPlayer(playerId).getPrincipal();
FinancialDataGatherer gatherer = new FinancialDataGatherer(w, pr);
return gatherer.sharesHeldByPublic();
}
int sharesOwnedByOtherPlayers(int playerId){
FreerailsPrincipal pr = w.getPlayer(playerId).getPrincipal();
FinancialDataGatherer gatherer = new FinancialDataGatherer(w, pr);
int[] stakes = gatherer.getStockInThisRRs();
int total = 0;
for (int i = 0; i < stakes.length; i++) {
if(i != playerId){
total+= stakes[i];
}
}
return total;
}
static Money calStockPrice(long netWorth, long profitLastyear, int publicShares, int otherRRShares){
if((publicShares + otherRRShares) == 0 ) return new Money(Long.MAX_VALUE);
long price = 2 * (5 * profitLastyear + netWorth) /(2 * publicShares + otherRRShares);
return new Money(price);
}
}

/**
* Generates a TimeTickMove.
*
* @author Luke
*
*/
@jfreerails.util.InstanceControlled
public class TimeTickPreMove implements PreMove {
private static final long serialVersionUID = 3690479125647208760L;
public static final TimeTickPreMove INSTANCE = new TimeTickPreMove();
private TimeTickPreMove() {
}
public Move generateMove(ReadOnlyWorld w) {
return TimeTickMove.getMove(w);
}
private Object readResolve() throws ObjectStreamException {
return INSTANCE;
}
}

/**
* Returns a path that goes forwards and backwards along the path passed to its
* constructor.
*
* @author Luke Lindsay 30-Oct-2002
*
*/
public class ToAndFroPathIterator implements FreerailsPathIterator {
private static final long serialVersionUID = 3256442525337202993L;
private FreerailsPathIterator path;
private boolean forwards = true;
private final List<Point> list;
public ToAndFroPathIterator(List<Point> l) {
list = l;
nextIterator();
}
private void nextIterator() {
path = new FreerailsPathIteratorImpl(list, forwards);
}
public boolean hasNext() {
if (list.size() < 2) {
return false;
}
return true;
}
public void nextSegment(IntLine line) {
if (this.hasNext()) {
if (!path.hasNext()) {
forwards = !forwards;
path = new FreerailsPathIteratorImpl(list, forwards);
}
path.nextSegment(line);
} else {
throw new NoSuchElementException();
}
}
}

/**
* Provides methods that generate moves that build, upgrade, and remove track.
*
* @author Luke
*/
final public class TrackMoveProducer {
private final ModelRoot mr;
private final MoveExecutor executor;
public enum BuildMode {
BUILD_TRACK, REMOVE_TRACK, UPGRADE_TRACK, IGNORE_TRACK, BUILD_STATION
}
private final Stack<Move> moveStack = new Stack<Move>();
private GameTime lastMoveTime = GameTime.BIG_BANG;
/**
* This generates the transactions - the charge - for the track being built.
*/
private final TrackMoveTransactionsGenerator transactionsGenerator;
public MoveStatus buildTrack(ImPoint from, Step[] path) {
MoveStatus returnValue = MoveStatus.MOVE_OK;
int x = from.x;
int y = from.y;
for (int i = 0; i < path.length; i++) {
returnValue = buildTrack(new ImPoint(x, y), path[i]);
x += path[i].deltaX;
y += path[i].deltaY;
if (!returnValue.ok) {
return returnValue;
}
}
return returnValue;
}
public MoveStatus buildTrack(ImPoint from, Step trackVector) {
ReadOnlyWorld w = executor.getWorld();
FreerailsPrincipal principal = executor.getPrincipal();
switch (getBuildMode()) {
case IGNORE_TRACK: {
return MoveStatus.MOVE_OK;
}
case REMOVE_TRACK: {
try {
ChangeTrackPieceCompositeMove move = ChangeTrackPieceCompositeMove
.generateRemoveTrackMove(from, trackVector, w,
principal);
Move moveAndTransaction = transactionsGenerator
.addTransactions(move);
return sendMove(moveAndTransaction);
} catch (Exception e) {
// thrown when there is no track to remove.
// Fix for bug [ 948670 ] Removing non-existent track
return MoveStatus.moveFailed("No track to remove.");
}
}
case BUILD_TRACK:
case UPGRADE_TRACK:
/*
* Do nothing yet since we need to work out what type of track to
* build.
*/
break;
}
assert (getBuildMode() == BuildMode.BUILD_TRACK || getBuildMode() == BuildMode.UPGRADE_TRACK);
int[] ruleIDs = new int[2];
TrackRule[] rules = new TrackRule[2];
int[] xs = { from.x, from.x + trackVector.deltaX };
int[] ys = { from.y, from.y + trackVector.deltaY };
for (int i = 0; i < ruleIDs.length; i++) {
int x = xs[i];
int y = ys[i];
FreerailsTile tile = (FreerailsTile) w.getTile(x, y);
int tt = tile.getTerrainTypeID();
ruleIDs[i] = getBuildTrackStrategy().getRule(tt);
if (ruleIDs[i] == -1) {
TerrainType terrainType = (TerrainType) w.get(
SKEY.TERRAIN_TYPES, tt);
String message = "Non of the selected track types can be built on "
+ terrainType.getDisplayName();
return MoveStatus.moveFailed(message);
}
rules[i] = (TrackRule) w.get(SKEY.TRACK_RULES, ruleIDs[i]);
}
switch (getBuildMode()) {
case UPGRADE_TRACK: {
// upgrade the from tile if necessary.
FreerailsTile tileA = (FreerailsTile) w.getTile(from.x, from.y);
if (tileA.getTrackPiece().getTrackTypeID() != ruleIDs[0] && !isStationHere(from)) {
MoveStatus ms = upgradeTrack(from, ruleIDs[0]);
if (!ms.ok) {
return ms;
}
}
ImPoint point = new ImPoint(from.x + trackVector.getDx(), from.y
+ trackVector.getDy());
FreerailsTile tileB = (FreerailsTile) w.getTile(point.x, point.y);
if (tileB.getTrackPiece().getTrackTypeID() != ruleIDs[1] && !isStationHere(point)) {
MoveStatus ms = upgradeTrack(point, ruleIDs[1]);
if (!ms.ok) {
return ms;
}
}
return MoveStatus.MOVE_OK;
}
case BUILD_TRACK: {
ChangeTrackPieceCompositeMove move = ChangeTrackPieceCompositeMove
.generateBuildTrackMove(from, trackVector, rules[0],
rules[1], w, principal);
Move moveAndTransaction = transactionsGenerator
.addTransactions(move);
return sendMove(moveAndTransaction);
}
default:
throw new IllegalArgumentException(String.valueOf(getBuildMode()));
}
}
public MoveStatus upgradeTrack(ImPoint point) {
if (getBuildMode() == BuildMode.UPGRADE_TRACK) {
ReadOnlyWorld w = executor.getWorld();
FreerailsTile tile = (FreerailsTile) w.getTile(point.x, point.y);
int tt = tile.getTerrainTypeID();
return upgradeTrack(point, getBuildTrackStrategy().getRule(tt));
}
throw new IllegalStateException(
"Track builder not set to upgrade track!");
}
public void setTrackBuilderMode(BuildMode i) {
setBuildMode(i);
}
public TrackMoveProducer(MoveExecutor executor, ReadOnlyWorld world, ModelRoot mr) {
if(null == mr) throw new NullPointerException();
this.executor = executor;
this.mr = mr;
FreerailsPrincipal principal = executor.getPrincipal();
transactionsGenerator = new TrackMoveTransactionsGenerator(world,
principal);
setBuildTrackStrategy(BuildTrackStrategy.getDefault(world));
}
public TrackMoveProducer(ModelRoot mr) {
this.executor = mr;
if(null == mr) throw new NullPointerException();
this.mr = mr;
ReadOnlyWorld world = executor.getWorld();
FreerailsPrincipal principal = executor.getPrincipal();
transactionsGenerator = new TrackMoveTransactionsGenerator(world,
principal);
setBuildTrackStrategy(BuildTrackStrategy.getDefault(world));
}
private MoveStatus upgradeTrack(ImPoint point, int trackRuleID) {
ReadOnlyWorld w = executor.getWorld();
TrackPiece before = ((FreerailsTile) w.getTile(point.x, point.y)).getTrackPiece();
/* Check whether there is track here. */
if (before.getTrackTypeID() == NullTrackType.NULL_TRACK_TYPE_RULE_NUMBER) {
return MoveStatus.moveFailed("No track to upgrade.");
}
FreerailsPrincipal principal = executor.getPrincipal();
int owner = ChangeTrackPieceCompositeMove.getOwner(principal, w);
TrackRule trackRule = (TrackRule) w.get(SKEY.TRACK_RULES, trackRuleID);
TrackPiece after = new TrackPieceImpl(before.getTrackConfiguration(),
trackRule, owner, trackRuleID);
/* We don't want to 'upgrade' a station to track. See bug 874416. */
if (before.getTrackRule().isStation()) {
return MoveStatus
.moveFailed("No need to upgrade track at station.");
}
Move move = UpgradeTrackMove.generateMove(before, after, point);
Move move2 = transactionsGenerator.addTransactions(move);
return sendMove(move2);
}
public MoveStatus undoLastTrackMove() {
clearStackIfStale();
if (moveStack.size() > 0) {
Move m = moveStack.pop();
UndoMove undoMove = new UndoMove(m);
MoveStatus ms = executor.doMove(undoMove);
if (!ms.ok) {
return MoveStatus.moveFailed("Can not undo building track!");
}
return ms;
}
return MoveStatus.moveFailed("No track to undo building!");
}
/**
* Moves are only un-doable if no game time has passed since they they were
* executed. This method clears the move stack if the moves were added to
* the stack at a time other than the current time.
*/
private void clearStackIfStale() {
ReadOnlyWorld w = executor.getWorld();
GameTime currentTime = w.currentTime();
if (!currentTime.equals(lastMoveTime)) {
moveStack.clear();
lastMoveTime = currentTime;
}
}
public BuildMode getTrackBuilderMode() {
return getBuildMode();
}
private MoveStatus sendMove(Move m) {
MoveStatus ms = executor.doMove(m);
if (ms.isOk()) {
clearStackIfStale();
moveStack.add(m);
}
return ms;
}
// public BuildTrackStrategy getBuildTrackStrategy() {
// return buildTrackStrategy;
// }
//
// public void setBuildTrackStrategy(BuildTrackStrategy buildTrackStrategy) {
// this.buildTrackStrategy = buildTrackStrategy;
// }
private boolean isStationHere(ImPoint p) {
ReadOnlyWorld w = executor.getWorld();
FreerailsTile tile = (FreerailsTile) w.getTile(p.x, p.y);
return tile.getTrackPiece().getTrackRule().isStation();
}
public void setBuildTrackStrategy(BuildTrackStrategy buildTrackStrategy) {
mr.setProperty(Property.BUILD_TRACK_STRATEGY, buildTrackStrategy);
}
public BuildTrackStrategy getBuildTrackStrategy() {
return (BuildTrackStrategy) mr.getProperty(Property.BUILD_TRACK_STRATEGY);
}
public void setBuildMode(BuildMode buildMode) {
mr.setProperty(Property.TRACK_BUILDER_MODE, buildMode);
}
public BuildMode getBuildMode() {
return (BuildMode) mr.getProperty(Property.TRACK_BUILDER_MODE);
}
}

/**
* Finds the best route to build track between two points.
*
* @author Luke
*
*/
public class TrackPathFinder implements IncrementalPathFinder {
private static final Logger logger = Logger.getLogger(TrackPathFinder.class
.getName());
private SimpleAStarPathFinder pathFinder = new SimpleAStarPathFinder();
private final ReadOnlyWorld world;
private ImPoint startPoint;
private final FreerailsPrincipal principal;
public TrackPathFinder(ReadOnlyWorld world, FreerailsPrincipal principal) {
this.world = world;
this.principal = principal;
}
public void abandonSearch() {
pathFinder.abandonSearch();
}
private List<ImPoint> convertPath2Points(IntArray path) {
PositionOnTrack progress = new PositionOnTrack();
List<ImPoint> proposedTrack = new ArrayList<ImPoint>();
ImPoint p;
for (int i = 0; i < path.size(); i++) {
progress.setValuesFromInt(path.get(i));
p = new ImPoint(progress.getX(), progress.getY());
proposedTrack.add(p);
logger.fine("Adding point " + p);
}
return proposedTrack;
}
private int[] findTargets(ImPoint targetPoint) {
FreerailsTile tile = (FreerailsTile) world.getTile(targetPoint.x,
targetPoint.y);
TrackPiece trackPiece = tile.getTrackPiece();
int ruleNumber = trackPiece.getTrackTypeID();
int[] targetInts;
if (tile.hasTrack()) {
/*
* If there is already track here, we need to check what directions
* we can build in without creating an illegal track config.
*/
TrackRule trackRule = (TrackRule) world.get(SKEY.TRACK_RULES,
ruleNumber);
/* Count number of possible directions. */
ArrayList<Step> possibleDirections = new ArrayList<Step>();
for (int i = 0; i < 8; i++) {
Step direction = Step.getInstance(i);
TrackConfiguration config = trackPiece.getTrackConfiguration();
TrackConfiguration testConfig = TrackConfiguration.add(config,
direction);
if (trackRule.trackPieceIsLegal(testConfig)) {
possibleDirections.add(direction);
}
}
/* Put them into an array. */
targetInts = new int[possibleDirections.size()];
for (int i = 0; i < targetInts.length; i++) {
Step direction = possibleDirections.get(i);
PositionOnTrack targetPot = PositionOnTrack.createFacing(
targetPoint.x, targetPoint.y, direction);
targetInts[i] = targetPot.toInt();
}
} else {
/* If there is no track here, we can go in any direction. */
targetInts = new int[8];
for (int i = 0; i < 8; i++) {
PositionOnTrack targetPot = PositionOnTrack.createComingFrom(
targetPoint.x, targetPoint.y, Step.getInstance(i));
targetInts[i] = targetPot.toInt();
}
}
return targetInts;
}
public List generatePath(ImPoint start, ImPoint targetPoint,
BuildTrackStrategy bts) throws PathNotFoundException {
setupSearch(start, targetPoint, bts);
pathFinder.search(-1);
IntArray path = pathFinder.retrievePath();
List proposedTrack = convertPath2Points(path);
return proposedTrack;
}
public int getStatus() {
return pathFinder.getStatus();
}
public List<ImPoint> pathAsPoints() {
IntArray path = pathFinder.retrievePath();
return convertPath2Points(path);
}
public Step[] pathAsVectors() {
IntArray path = pathFinder.retrievePath();
int size = path.size();
Step[] vectors = new Step[size];
PositionOnTrack progress = new PositionOnTrack();
int x = startPoint.x;
int y = startPoint.y;
for (int i = 0; i < size; i++) {
progress.setValuesFromInt(path.get(i));
int x2 = progress.getX();
int y2 = progress.getY();
vectors[i] = Step.getInstance(x2 - x, y2 - y);
x = x2;
y = y2;
}
return vectors;
}
public void search(long maxDuration) throws PathNotFoundException {
pathFinder.search(maxDuration);
}
public void setupSearch(ImPoint startPoint, ImPoint targetPoint,
BuildTrackStrategy bts) throws PathNotFoundException {
logger
.fine("Find track path from " + startPoint + " to "
+ targetPoint);
this.startPoint = startPoint;
int[] targetInts = findTargets(targetPoint);
int[] startInts = findTargets(startPoint);
BuildTrackExplorer explorer = new BuildTrackExplorer(world,
principal, startPoint, targetPoint);
explorer.setBuildTrackStrategy(bts);
pathFinder.setupSearch(startInts, targetInts, explorer);
}
}

/**
* Provides convenience methods to access the properties of a train from the
* world object.
*
* @author Luke
*
*/
public class TrainAccessor {
private final ReadOnlyWorld w;
private final FreerailsPrincipal p;
private final int id;
public TrainAccessor(final ReadOnlyWorld w, final FreerailsPrincipal p,
final int id) {
this.w = w;
this.p = p;
this.id = id;
}
public int getId() {
return id;
}
public SpeedTimeAndStatus.TrainActivity getStatus(double time){
TrainMotion tm = findCurrentMotion(time);
return tm.getActivity();
}
/**
* Checks the track under the train's final position still exists (i.e.
* has not been bulldozed).
*/
public boolean trackExists() {
ActivityIterator ai = w.getActivities(p, id);
ai.gotoLastActivity();
TrainMotion tm = (TrainMotion) ai.getActivity();
PositionOnTrack pot = tm.getFinalPosition();
int x = pot.getX();
int y = pot.getY();
FreerailsTile tile = (FreerailsTile) w.getTile(x, y);
TrackPiece trackPiece = tile.getTrackPiece();
TrackConfiguration present = trackPiece.getTrackConfiguration();
TrackConfiguration needed = TrackConfiguration.getFlatInstance(pot.cameFrom());
return present.contains(needed);
}
/**
* @return the id of the station the train is currently at, or -1 if no
* current station.
*
*/
public int getStationId(double time){
TrainMotion tm = findCurrentMotion(time);
PositionOnTrack pot = tm.getFinalPosition();
int x = pot.getX();
int y = pot.getY();
//loop thru the station list to check if train is at the same Point
// as
// a station
for (int i = 0; i < w.size(p, KEY.STATIONS); i++) {
StationModel tempPoint = (StationModel) w.get(p, KEY.STATIONS, i);
if (null != tempPoint && (x == tempPoint.x) && (y == tempPoint.y)) {
return i; // train is at the station at location tempPoint
}
}
return -1;
}
public TrainPositionOnMap findPosition(double time) {
ActivityIterator ai = w.getActivities(p, id);
ai.gotoLastActivity();
while (ai.getStartTime() > time && ai.hasPrevious()) {
ai.previousActivity();
}
double dt = time - ai.getStartTime();
dt = Math.min(dt, ai.getDuration());
TrainMotion tm = (TrainMotion) ai.getActivity();
return tm.getState(dt);
}
public TrainMotion findCurrentMotion(double time) {
ActivityIterator ai = w.getActivities(p, id);
ai.gotoLastActivity();
while (ai.getStartTime() > time && ai.hasPrevious()) {
ai.previousActivity();
}
return (TrainMotion) ai.getActivity();
}
public TrainModel getTrain() {
return (TrainModel) w.get(p, KEY.TRAINS, id);
}
public ImmutableSchedule getSchedule() {
TrainModel train = getTrain();
return (ImmutableSchedule) w.get(p, KEY.TRAIN_SCHEDULES, train
.getScheduleID());
}
public ImmutableCargoBundle getCargoBundle() {
TrainModel train = getTrain();
return (ImmutableCargoBundle) w.get(p, KEY.CARGO_BUNDLES, train
.getCargoBundleID());
}
/**
* Returns true iff all the following hold.
* <ol>
* <li>The train is waiting for a full load at some station X.</li>
* <li>The current train order tells the train to goto station X.</li>
* <li>The current train order tells the train to wait for a full load.</li>
* <li>The current train order specifies a consist that matches the train's current consist.</li>
* </ol>
*
*/
public boolean keepWaiting(){
double time = w.currentTime().getTicks();
int stationId = getStationId(time);
if (stationId == -1)
return false;
SpeedTimeAndStatus.TrainActivity act = getStatus(time);
if (act != TrainActivity.WAITING_FOR_FULL_LOAD)
return false;
ImmutableSchedule schedule = getSchedule();
if(schedule.getNumOrders() <1){
//We end up here if all the train orders are deleted while a train
//is waiting for a full load.
return false;
}
TrainOrdersModel order = schedule.getOrder(schedule.getOrderToGoto());
if (order.stationId != stationId)
return false;
if (!order.waitUntilFull)
return false;
TrainModel train = getTrain();
return order.getConsist().equals(train.getConsist());
}
/**
* @return the location of the station the train is currently heading
* towards.
*/
public ImPoint getTarget() {
TrainModel train = (TrainModel) w.get(p, KEY.TRAINS, id);
int scheduleID = train.getScheduleID();
ImmutableSchedule schedule = (ImmutableSchedule) w.get(
p, KEY.TRAIN_SCHEDULES, scheduleID);
int stationNumber = schedule.getStationToGoto();
if (-1 == stationNumber) {
// There are no stations on the schedule.
return new ImPoint(0, 0);
}
StationModel station = (StationModel) w.get(p,
KEY.STATIONS, stationNumber);
return new ImPoint(station.x, station.y);
}
public HashSet<TrackSection> occupiedTrackSection(double time){
TrainMotion tm = findCurrentMotion(time);
PathOnTiles path = tm.getPath();
HashSet<TrackSection> sections = new HashSet<TrackSection>();
ImPoint start = path.getStart();
int x = start.x;
int y = start.y;
for (int i = 0; i < path.steps(); i++) {
Step s = path.getStep(i);
ImPoint tile = new ImPoint(x, y);
x+=s.deltaX;
y+=s.deltaY;
sections.add(new TrackSection(s, tile));
}
return sections;
}
public boolean isMoving(double time){
TrainMotion tm = findCurrentMotion(time);
double speed = tm.getSpeedAtEnd();
return speed != 0;
}
/** The space available on the train measured in cargo units.*/
public ImInts spaceAvailable(){
TrainModel train = (TrainModel) w.get(p, KEY.TRAINS, id);
ImmutableCargoBundle bundleOnTrain = (ImmutableCargoBundle) w.get(p,
KEY.CARGO_BUNDLES, train.getCargoBundleID());
return spaceAvailable2(w, bundleOnTrain, train.getConsist());
}
public static ImInts spaceAvailable2(ReadOnlyWorld row, ImmutableCargoBundle onTrain, ImInts consist){
// This array will store the amount of space available on the train for
// each cargo type.
final int NUM_CARGO_TYPES = row.size(SKEY.CARGO_TYPES);
int[] spaceAvailable = new int[NUM_CARGO_TYPES];
// First calculate the train's total capacity.
for (int j = 0; j < consist.size(); j++) {
int cargoType = consist.get(j);
spaceAvailable[cargoType] += WagonType.UNITS_OF_CARGO_PER_WAGON;
}
for (int cargoType = 0; cargoType < NUM_CARGO_TYPES; cargoType++) {
spaceAvailable[cargoType]= spaceAvailable[cargoType] - onTrain.getAmount(cargoType);
}
return new ImInts(spaceAvailable);
}
}

/**
* FlatTrackExplorer to FreerailsIntIterator adapter.
*
* @author Luke Lindsay 30-Nov-2002.
*
*/
public class TrainPathIntIterator implements FreerailsIntIterator {
private final FlatTrackExplorer trackExplorer;
public TrainPathIntIterator(FlatTrackExplorer t) {
trackExplorer = t;
}
public boolean hasNextInt() {
return trackExplorer.hasNextEdge();
}
public int nextInt() {
trackExplorer.nextEdge();
trackExplorer.moveForward();
return trackExplorer.getPosition();
}
}

/**
* @author Luke
*
*/
public class TrainStopsHandler implements Serializable {
private static final Logger logger = Logger.getLogger(TrainStopsHandler.class.getName());
private static final int NOT_AT_STATION = -1;
private static final long serialVersionUID = 3257567287094882872L;
/** If wagons are added to a train, we need to increase its length.*/
static PathOnTiles lengthenPath(ReadOnlyWorld w, PathOnTiles path, int currentTrainLength) {
double pathDistance = path.getTotalDistance();
double extraDistanceNeeded = currentTrainLength - pathDistance;
List<Step> steps = new ArrayList<Step>();
ImPoint start = path.getStart();
Step firstStep = path.getStep(0);
PositionOnTrack nextPot = PositionOnTrack.createComingFrom(start.x, start.y, firstStep);
while( extraDistanceNeeded > 0){
FlatTrackExplorer fte = new FlatTrackExplorer(w, nextPot);
fte.nextEdge();
nextPot.setValuesFromInt(fte.getVertexConnectedByEdge());
Step cameFrom = nextPot.facing();
steps.add(0, cameFrom);
extraDistanceNeeded -= cameFrom.getLength();
}
//Add existing steps
for (int i = 0; i < path.steps(); i++) {
Step step = path.getStep(i);
steps.add(step);
}
ImPoint newStart = new ImPoint(nextPot.getX(), nextPot.getY());
path = new PathOnTiles(newStart, steps);
return path;
}
private final FreerailsPrincipal principal;
private GameTime timeLoadingFinished = new GameTime(0);
private final int trainId;
private final WorldDiffs worldDiffs;
public TrainStopsHandler(int id, FreerailsPrincipal p, WorldDiffs w) {
trainId = id;
principal = p;
worldDiffs = w;
}
public ImPoint arrivesAtPoint(int x, int y) {
TrainAccessor ta = new TrainAccessor(worldDiffs, principal, trainId);
ImPoint targetPoint = ta.getTarget();
if (x == targetPoint.x && y == targetPoint.y) {
updateTarget();
targetPoint = ta.getTarget();
} else {
int stationNumber = getStationID(x, y);
if (NOT_AT_STATION != stationNumber) {
loadAndUnloadCargo(stationNumber, false, false);
}
}
return targetPoint;
}
public Move getMoves() {
Move m = WorldDiffMove.generate(worldDiffs, WorldDiffMove.Cause.TrainArrives);
worldDiffs.reset();
return m;
}
/**
* @return the number of the station the train is currently at, or -1 if no
* current station.
*/
public int getStationID(int x, int y) {
// loop thru the station list to check if train is at the same Point
// as
// a station
for (int i = 0; i < worldDiffs.size(principal, KEY.STATIONS); i++) {
StationModel tempPoint = (StationModel) worldDiffs.get(principal, KEY.STATIONS, i);
if (null != tempPoint && (x == tempPoint.x) && (y == tempPoint.y)) {
return i; // train is at the station at location tempPoint
}
}
return -1;
// there are no stations that exist where the train is currently
}
public int getTrainLength() {
TrainAccessor ta = new TrainAccessor(worldDiffs, principal, trainId);
return ta.getTrain().getLength();
}
public boolean isTrainFull() {
TrainAccessor train = new TrainAccessor(worldDiffs, principal, trainId);
ImInts spaceAvailable = train.spaceAvailable();
return spaceAvailable.sum() == 0;
}
public boolean isTrainMoving() {
if (refreshWaitingForFullLoad()) {
return false;
}
GameTime time = worldDiffs.currentTime();
return time.getTicks() > this.timeLoadingFinished.getTicks();
}
public boolean isWaiting4FullLoad() {
TrainModel train = (TrainModel) worldDiffs.get(principal, KEY.TRAINS, this.trainId);
int scheduleID = train.getScheduleID();
ImmutableSchedule schedule = (ImmutableSchedule) worldDiffs.get(principal,
KEY.TRAIN_SCHEDULES, scheduleID);
if(schedule.getNumOrders() == 0){
return false;
}
TrainOrdersModel order = schedule.getOrder(schedule.getOrderToGoto());
return !isTrainFull() && order.waitUntilFull;
}
void loadAndUnloadCargo(int stationId, boolean waiting, boolean autoConsist) {
// train is at a station so do the cargo processing
DropOffAndPickupCargoMoveGenerator transfer = new DropOffAndPickupCargoMoveGenerator(
trainId, stationId, worldDiffs, principal, waiting, autoConsist);
Move m = transfer.generateMove();
if(null != m){
MoveStatus ms = m.doMove(worldDiffs, principal);
if (!ms.ok)
throw new IllegalStateException(ms.message);
}
}
void makeTrainWait(int ticks) {
GameTime currentTime = worldDiffs.currentTime();
timeLoadingFinished = new GameTime(currentTime.getTicks() + ticks);
}
public boolean refreshWaitingForFullLoad() {
TrainAccessor ta = new TrainAccessor(worldDiffs, principal, trainId);
ImmutableSchedule schedule = ta.getSchedule();
int stationId = ta.getStationId(Double.MAX_VALUE);
if(stationId<0) throw new IllegalStateException();
//The train's orders may have changed...
final int orderToGoto = schedule.getOrderToGoto();
if(-1 == orderToGoto){
//We end up here if all the orders are deleted.
return false;
}
TrainOrdersModel order = schedule.getOrder(orderToGoto);
//Should we go to another station?
if(stationId != order.stationId){
return false;
}
//Should we change the consist?
ImInts consist = ta.getTrain().getConsist();
if(!consist.equals(order.consist)){
// ..if so, we should change the consist.
int oldLength = ta.getTrain().getLength();
int engineType = ta.getTrain().getEngineType();
TrainModel newTrain = ta.getTrain().getNewInstance(engineType, order.consist);
worldDiffs.set(principal, KEY.TRAINS, trainId, newTrain);
int newLength = newTrain.getLength();
//has the trains length increased?
if(newLength > oldLength){
TrainMotion tm = ta.findCurrentMotion(Double.MAX_VALUE);
PathOnTiles path = tm.getPath();
path = lengthenPath(worldDiffs, path, oldLength);
SpeedTimeAndStatus.TrainActivity status = isWaiting4FullLoad() ? WAITING_FOR_FULL_LOAD : STOPPED_AT_STATION;
TrainMotion nextMotion = new TrainMotion(path, newLength,
0, status);
// Create a new Move object.
Move trainMove = new NextActivityMove(nextMotion, trainId,
principal);
MoveStatus ms = trainMove.doMove(worldDiffs, Player.AUTHORITATIVE);
if(!ms.ok) throw new IllegalStateException(ms.message);
}
}
/* Add any cargo that is waiting. */
loadAndUnloadCargo(schedule.getStationToGoto(), order.waitUntilFull, order.autoConsist);
//Should we stop waiting?
if(!order.waitUntilFull){
updateSchedule();
return false;
}
if (isTrainFull()) {
updateSchedule();
return false;
}
return true;
}
private void scheduledStop() {
TrainModel train = (TrainModel) worldDiffs.get(principal, KEY.TRAINS, this.trainId);
Schedule schedule = (ImmutableSchedule) worldDiffs.get(principal, KEY.TRAIN_SCHEDULES,
train.getScheduleID());
ImInts wagonsToAdd = schedule.getWagonsToAdd();
// Loading and unloading cargo takes time, so we make the train wait for
// a few ticks.
makeTrainWait(50);
boolean autoConsist = schedule.autoConsist();
if (null != wagonsToAdd) {
int engine = train.getEngineType();
Move m = ChangeTrainMove.generateMove(this.trainId, train, engine, wagonsToAdd,
principal);
m.doMove(worldDiffs, principal);
}
updateSchedule();
int stationToGoto = schedule.getStationToGoto();
loadAndUnloadCargo(stationToGoto, true, autoConsist);
}
void updateSchedule() {
TrainModel train = (TrainModel) worldDiffs.get(principal, KEY.TRAINS, this.trainId);
int scheduleID = train.getScheduleID();
ImmutableSchedule currentSchedule = (ImmutableSchedule) worldDiffs.get(principal,
KEY.TRAIN_SCHEDULES, scheduleID);
MutableSchedule schedule = new MutableSchedule(currentSchedule);
StationModel station = null;
TrainOrdersModel order = schedule.getOrder(schedule.getOrderToGoto());
boolean waiting4FullLoad = order.waitUntilFull && !isTrainFull();
if (!waiting4FullLoad) {
schedule.gotoNextStation();
ImmutableSchedule newSchedule = schedule.toImmutableSchedule();
worldDiffs.set(principal, KEY.TRAIN_SCHEDULES, scheduleID, newSchedule);
int stationNumber = schedule.getStationToGoto();
station = (StationModel) worldDiffs.get(principal, KEY.STATIONS, stationNumber);
if (null == station) {
logger.warning("null == station, train " + trainId
+ " doesn't know where to go next!");
}
}
}
/**
* Issues a ChangeTrainScheduleMove to set the train to move to the next
* station.
*/
public void updateTarget() {
scheduledStop();
}
}

/**
*
* @author Luke
*/
public class UnexpectedExceptionForm extends javax.swing.JFrame {
private static final long serialVersionUID = -4348641764811196495L;
/** Creates new form UnexpectedExceptionForm */
public UnexpectedExceptionForm() {
initComponents();
}
public void setText(String s){
copyableTextJPanel1.setText(s);
}
/** This method is called from within the constructor to
* initialize the form.
* WARNING: Do NOT modify this code. The content of this method is
* always regenerated by the Form Editor.
*/
// <editor-fold defaultstate="collapsed" desc=" Generated Code ">//GEN-BEGIN:initComponents
private void initComponents() {
java.awt.GridBagConstraints gridBagConstraints;
copyableTextJPanel1 = new jfreerails.controller.CopyableTextJPanel();
closebutton = new javax.swing.JButton();
getContentPane().setLayout(new java.awt.GridBagLayout());
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
setTitle("Unexpected Exception");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
getContentPane().add(copyableTextJPanel1, gridBagConstraints);
closebutton.setText("Close");
closebutton.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
closebuttonActionPerformed(evt);
}
});
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.insets = new java.awt.Insets(7, 7, 7, 7);
getContentPane().add(closebutton, gridBagConstraints);
pack();
}
// </editor-fold>//GEN-END:initComponents
private void closebuttonActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_closebuttonActionPerformed
System.exit(1);
}//GEN-LAST:event_closebuttonActionPerformed
/**
* @param args the command line arguments
*/
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
UnexpectedExceptionForm unexpectedExceptionForm = new UnexpectedExceptionForm();
Exception e = new Exception("Oh No..");
String str = ReportBugTextGenerator.genText(e);
unexpectedExceptionForm.setText(str);
unexpectedExceptionForm.setVisible(true);
e.printStackTrace();
}
});
}
// Variables declaration - do not modify//GEN-BEGIN:variables
javax.swing.JButton closebutton;
jfreerails.controller.CopyableTextJPanel copyableTextJPanel1;
// End of variables declaration//GEN-END:variables
}

/**
* Class to verify that the chosen name for a station hasn't already been taken
* by another station. If the name has been used, a minor alteration in the name
* is required, by adding perhaps "Junction" or "Siding" to the name.
*
* @author Scott Bennett
*
* Date: 12th April 2003
*
*/
public class VerifyStationName {
private final ReadOnlyWorld w;
private final String nameToVerify;
private final Vector<String> stationAlternatives;
public VerifyStationName(ReadOnlyWorld world, String name) {
this.w = world;
this.nameToVerify = name;
this.stationAlternatives = new Vector<String>();
stationAlternatives.addElement("Junction");
stationAlternatives.addElement("Siding");
stationAlternatives.addElement("North");
stationAlternatives.addElement("East");
stationAlternatives.addElement("South");
stationAlternatives.addElement("West");
}
public String getName() {
String appropriateName = nameToVerify;
boolean found = false;
String tempName = null;
// if (w.size(KEY.STATIONS) <= 0) {
// //if there are no stations, then obviously the name isn't taken
// return appropriateName;
// }
found = checkStationExists(appropriateName);
if (!found) {
return appropriateName;
}
// a station with that name already exists, so we need to find another
// name
for (int i = 0; i < stationAlternatives.size(); i++) {
tempName = appropriateName + " " + stationAlternatives.elementAt(i);
found = checkStationExists(tempName);
if (!found) {
return tempName;
}
}
int j = 7; // for number of names that have already been used
while (found) {
j++;
tempName = appropriateName + "Station #" + j;
found = checkStationExists(tempName);
}
return tempName;
}
private boolean checkStationExists(String name) {
String testName = name;
StationModel tempStation;
for (int i = 0; i < w.getNumberOfPlayers(); i++) {
FreerailsPrincipal principal = w.getPlayer(i).getPrincipal();
WorldIterator wi = new NonNullElements(KEY.STATIONS, w, principal);
while (wi.next()) { // loop over non null stations
tempStation = (StationModel) wi.getElement();
if ((testName).equals(tempStation.getStationName())) {
// station already exists with that name
return true;
}
}
}
// no stations exist with that name
return false;
}
}

/**
* The Launcher panel that lets you choose fullscreen or windowed mode and the
* screen resolution etc.
*
* @author rtuck99@users.sourceforge.net
* @author Luke Lindsay
*/
class ClientOptionsJPanel extends javax.swing.JPanel implements LauncherPanel {
private static final long serialVersionUID = 3256721779883325748L;
private static final Logger logger = Logger
.getLogger(ClientOptionsJPanel.class.getName());
private final LauncherInterface owner;
private String[] names;
private static final String INVALID_PORT = "A valid port value is between between 0 and 65535.";
private final DocumentListener documentListener = new DocumentListener() {
public void insertUpdate(DocumentEvent e) {
validateInput();
}
public void removeUpdate(DocumentEvent e) {
validateInput();
}
public void changedUpdate(DocumentEvent e) {
validateInput();
}
};
/**
* If the user has opted to load a game, we need to limit the list of
* players to participants in the game we are loading. Otherwise, any player
* name is OK. Either, pass in a array of names or null if any name is OK.
*/
void limitPlayerNames(String[] n) {
this.names = n;
if (names == null) {
playerName.setVisible(true);
playerNames.setVisible(false);
playerName.setEditable(true);
} else {
if (names.length == 1) {
playerName.setVisible(true);
playerNames.setVisible(false);
playerName.setText(n[0]);
playerName.setEditable(false);
} else {
playerName.setVisible(false);
playerNames.setVisible(true);
ComboBoxModel model = new DefaultComboBoxModel(names);
playerNames.setModel(model);
}
}
this.revalidate();
}
String getPlayerName() {
if (playerName.isVisible()) {
return playerName.getText();
}
int index = playerNames.getSelectedIndex();
if (index < 0)
return null; // no selection.
return names[index];
}
DisplayMode getDisplayMode() {
if (this.fullScreenButton.isSelected()) {
MyDisplayMode displayMode = ((MyDisplayMode) jList1
.getSelectedValue());
logger.fine("The selected display mode is "
+ displayMode.toString());
return displayMode.displayMode;
}
return null;
}
InetSocketAddress getRemoteServerAddress() {
String portStr = remotePort.getText();
if (portStr == null) {
return null;
}
int port;
try {
port = Integer.parseInt(portStr);
} catch (NumberFormatException e) {
return null;
}
InetSocketAddress address;
try {
address = new InetSocketAddress(remoteIP.getText(), port);
} catch (IllegalArgumentException e) {
return null;
}
/*
* cut and pasted InetSocketAddress isa = getRemoteServerAddress(); if
* (isa == null) { infoText = "Please enter a valid remote server
* address"; } else if (isa.isUnresolved()) { infoText = "Couldn't
* resolve remote server address"; } else { isValid = true; }
*/
return address;
}
public boolean validateInput() {
/* Validate player name. */
if (playerName.getText() == null || playerName.getText().equals("")) {
owner.setInfoText("Please set a name for your player",
LauncherInterface.ERROR);
return false;
}
/* Validate host name. */
if (remoteIP.getText() == null || remoteIP.getText().equals("")) {
owner.setInfoText("Please enter a host name",
LauncherInterface.ERROR);
return false;
}
/* Validate port. */
try {
int port = Integer.parseInt(remotePort.getText());
if (port < 0 || port > 65535) {
owner.setInfoText(INVALID_PORT, LauncherInterface.ERROR);
return false;
}
} catch (Exception e) {
owner.setInfoText(INVALID_PORT, LauncherInterface.ERROR);
return false;
}
/*
* Validate display-mode selection. Note, on some systems the display
* mode can't be changed, in which case the list of selectable display
* modes will have length 0.
*/
if (fullScreenButton.isSelected() && jList1.getModel().getSize() > 0
&& jList1.getSelectedIndex() == -1) {
owner
.setInfoText("Select a display-mode.",
LauncherInterface.ERROR);
return false;
}
/* Everything is ok. */
owner.hideErrorMessages();
owner.setProperty("freerails.server.port", this.remotePort.getText());
owner.setProperty("freerails.player.name", this.playerName.getText());
owner.setProperty("freerails.server.ip.address", this.remoteIP.getText());
owner.saveProps();
return true;
}
int getScreenMode() {
if (this.fullScreenButton.isSelected()) {
return ScreenHandler.FULL_SCREEN;
} else if (this.windowedButton.isSelected()) {
return ScreenHandler.WINDOWED_MODE;
} else if (this.fixedSizeButton.isSelected()) {
return ScreenHandler.FIXED_SIZE_WINDOWED_MODE;
} else {
throw new IllegalStateException();
}
}
public void setControlsEnabled(boolean enabled) {
windowedButton.setEnabled(enabled);
fullScreenButton.setEnabled(enabled);
fixedSizeButton.setEnabled(enabled);
if (fullScreenButton.isSelected()) {
jList1.setEnabled(enabled);
}
}
private final DisplayModesComboBoxModels listModel;
void setRemoteServerPanelVisible(boolean b) {
this.jPanel4.setVisible(b);
}
public ClientOptionsJPanel(LauncherInterface owner) {
this.owner = owner;
initComponents();
listModel = new DisplayModesComboBoxModels();
listModel.removeDisplayModesBelow(640, 480, 16);
jList1.setModel(listModel);
jList1.setSelectedIndex(0);
validateInput();
// Listen for changes in the server port text box.
remotePort.getDocument().addDocumentListener(documentListener);
remoteIP.getDocument().addDocumentListener(documentListener);
playerName.getDocument().addDocumentListener(documentListener);
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
private void initComponents() {// GEN-BEGIN:initComponents
java.awt.GridBagConstraints gridBagConstraints;
buttonGroup1 = new javax.swing.ButtonGroup();
jPanel3 = new javax.swing.JPanel();
jLabel1 = new javax.swing.JLabel();
playerName = new javax.swing.JTextField();
playerNames = new javax.swing.JComboBox();
jPanel4 = new javax.swing.JPanel();
jLabel2 = new javax.swing.JLabel();
remoteIP = new javax.swing.JTextField();
jLabel3 = new javax.swing.JLabel();
remotePort = new javax.swing.JTextField();
spacer = new javax.swing.JPanel();
jPanel1 = new javax.swing.JPanel();
jScrollPane1 = new javax.swing.JScrollPane();
jList1 = new javax.swing.JList();
jPanel2 = new javax.swing.JPanel();
windowedButton = new javax.swing.JRadioButton();
fixedSizeButton = new javax.swing.JRadioButton();
fullScreenButton = new javax.swing.JRadioButton();
setLayout(new java.awt.GridBagLayout());
addComponentListener(new java.awt.event.ComponentAdapter() {
@Override
public void componentShown(java.awt.event.ComponentEvent evt) {
formComponentShown(evt);
}
});
jPanel3.setLayout(new java.awt.FlowLayout(java.awt.FlowLayout.LEFT));
jPanel3.setBorder(new javax.swing.border.TitledBorder(
new javax.swing.border.EtchedBorder(), "Player Details"));
jLabel1.setText("Player name:");
jPanel3.add(jLabel1);
playerName.setColumns(12);
playerName.setText(owner.getProperty("freerails.player.name"));
jPanel3.add(playerName);
playerNames.setToolTipText("Select a player from the saved game.");
jPanel3.add(playerNames);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
add(jPanel3, gridBagConstraints);
jPanel4.setLayout(new java.awt.GridBagLayout());
jPanel4
.setBorder(new javax.swing.border.TitledBorder(
new javax.swing.border.EtchedBorder(),
"Remote server address"));
jPanel4.setEnabled(false);
jLabel2.setText("IP Address:");
jPanel4.add(jLabel2, new java.awt.GridBagConstraints());
remoteIP.setColumns(15);
remoteIP.setText(owner.getProperty("freerails.server.ip.address"));
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
gridBagConstraints.insets = new java.awt.Insets(5, 5, 5, 5);
jPanel4.add(remoteIP, gridBagConstraints);
jLabel3.setText("port");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
gridBagConstraints.insets = new java.awt.Insets(5, 5, 5, 5);
jPanel4.add(jLabel3, gridBagConstraints);
remotePort.setColumns(5);
remotePort.setText(owner.getProperty("freerails.server.port"));
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 1;
gridBagConstraints.gridy = 1;
gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
gridBagConstraints.insets = new java.awt.Insets(5, 5, 5, 5);
jPanel4.add(remotePort, gridBagConstraints);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
gridBagConstraints.weightx = 1.0;
jPanel4.add(spacer, gridBagConstraints);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
gridBagConstraints.weightx = 1.0;
add(jPanel4, gridBagConstraints);
jPanel1.setLayout(new java.awt.BorderLayout());
jPanel1.setBorder(new javax.swing.border.TitledBorder(
new javax.swing.border.EtchedBorder(), "Select Display Mode"));
jScrollPane1.setBorder(new javax.swing.border.BevelBorder(
javax.swing.border.BevelBorder.LOWERED));
jList1
.setSelectionMode(javax.swing.ListSelectionModel.SINGLE_SELECTION);
jList1.setEnabled(false);
jList1
.addListSelectionListener(new javax.swing.event.ListSelectionListener() {
public void valueChanged(
javax.swing.event.ListSelectionEvent evt) {
jList1ValueChanged(evt);
}
});
jScrollPane1.setViewportView(jList1);
jPanel1.add(jScrollPane1, java.awt.BorderLayout.CENTER);
jPanel2.setLayout(new javax.swing.BoxLayout(jPanel2,
javax.swing.BoxLayout.Y_AXIS));
buttonGroup1.add(windowedButton);
windowedButton.setSelected(true);
windowedButton.setText("Windowed");
jPanel2.add(windowedButton);
buttonGroup1.add(fixedSizeButton);
fixedSizeButton.setText("Windowed (fixed size 640*480)");
jPanel2.add(fixedSizeButton);
buttonGroup1.add(fullScreenButton);
fullScreenButton.setText("Full screen");
fullScreenButton
.addChangeListener(new javax.swing.event.ChangeListener() {
public void stateChanged(javax.swing.event.ChangeEvent evt) {
fullScreenButtonStateChanged(evt);
}
});
jPanel2.add(fullScreenButton);
jPanel1.add(jPanel2, java.awt.BorderLayout.NORTH);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 2;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
add(jPanel1, gridBagConstraints);
}// GEN-END:initComponents
private void jList1ValueChanged(javax.swing.event.ListSelectionEvent evt) {// GEN-FIRST:event_jList1ValueChanged
validateInput();
}// GEN-LAST:event_jList1ValueChanged
private void formComponentShown(java.awt.event.ComponentEvent evt) {// GEN-FIRST:event_formComponentShown
validateInput();
}// GEN-LAST:event_formComponentShown
private void fullScreenButtonStateChanged(javax.swing.event.ChangeEvent evt) {// GEN-FIRST:event_fullScreenButtonStateChanged
jList1.setEnabled(fullScreenButton.isSelected());
validateInput();
}// GEN-LAST:event_fullScreenButtonStateChanged
// Variables declaration - do not modify//GEN-BEGIN:variables
javax.swing.ButtonGroup buttonGroup1;
javax.swing.JRadioButton fixedSizeButton;
javax.swing.JRadioButton fullScreenButton;
javax.swing.JLabel jLabel1;
javax.swing.JLabel jLabel2;
javax.swing.JLabel jLabel3;
javax.swing.JList jList1;
javax.swing.JPanel jPanel1;
javax.swing.JPanel jPanel2;
javax.swing.JPanel jPanel3;
javax.swing.JPanel jPanel4;
javax.swing.JScrollPane jScrollPane1;
javax.swing.JTextField playerName;
javax.swing.JComboBox playerNames;
javax.swing.JTextField remoteIP;
javax.swing.JTextField remotePort;
javax.swing.JPanel spacer;
javax.swing.JRadioButton windowedButton;
// End of variables declaration//GEN-END:variables
}

/**
* A JPanel that shows the players currently logged in to the server.
*
* @author Luke
*/
public class ConnectedPlayersJPanel extends javax.swing.JPanel implements
PropertyChangeListener {
private static final long serialVersionUID = 4049080453489111344L;
FreerailsGameServer server = null;
/** Creates new form ConnectedPlayersJPanel */
public ConnectedPlayersJPanel() {
initComponents();
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
private void initComponents() {// GEN-BEGIN:initComponents
java.awt.GridBagConstraints gridBagConstraints;
title = new javax.swing.JLabel();
jScrollPane1 = new javax.swing.JScrollPane();
jList1 = new javax.swing.JList();
setLayout(new java.awt.GridBagLayout());
title.setText("Connected Players");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.insets = new java.awt.Insets(7, 7, 7, 7);
add(title, gridBagConstraints);
jList1.setModel(new javax.swing.AbstractListModel() {
private static final long serialVersionUID = 1L;
String[] strings = { "No players are logged on!" };
public int getSize() {
return strings.length;
}
public Object getElementAt(int i) {
return strings[i];
}
});
jScrollPane1.setViewportView(jList1);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
add(jScrollPane1, gridBagConstraints);
}// GEN-END:initComponents
void updateListOfPlayers() {
if (null != server) {
String[] playerNames = server.getPlayerNames();
playerNames = playerNames.length == 0 ? new String[] { "No players are logged on!" }
: playerNames;
setListOfPlayers(playerNames);
}
}
void setListOfPlayers(String[] players) {
jList1.setListData(players);
}
/** Called by the server when a player is added or removed. */
public void propertyChange(PropertyChangeEvent evt) {
if (evt.getPropertyName().equals(FreerailsGameServer.CONNECTED_PLAYERS)) {
if (EventQueue.isDispatchThread()) {
updateListOfPlayers();
} else {
EventQueue.invokeLater(new Runnable() {
public void run() {
updateListOfPlayers();
}
});
}
}
}
// Variables declaration - do not modify//GEN-BEGIN:variables
javax.swing.JList jList1;
javax.swing.JScrollPane jScrollPane1;
javax.swing.JLabel title;
// End of variables declaration//GEN-END:variables
}

/**
* A swing freerails client.
*
* @author Luke
*
*/
public class GUIClient extends FreerailsClient implements
FreerailsProgressMonitor {
public static void main(String[] args) {
try {
GUIClient client = new GUIClient("Test", null,
ScreenHandler.WINDOWED_MODE, null);
client.start();
} catch (IOException e) {
e.printStackTrace();
}
}
private final ActionRoot actionRoot;
private final GUIComponentFactoryImpl factory;
private final ModelRootImpl modelRoot;
private final FreerailsProgressMonitor monitor;
private final String name;
private final ScreenHandler screenHandler;
private RenderersRoot vl;
public GUIClient(String name, FreerailsProgressMonitor fm, int screenMode,
DisplayMode dm) throws IOException {
this.name = name;
this.monitor = null == fm ? this : fm;
// Set up model root and action root.
modelRoot = new ModelRootImpl();
modelRoot.setMoveFork(this.getMoveFork());
modelRoot.setMoveReceiver(this);
modelRoot.setServerCommandReceiver(this);
actionRoot = new ActionRoot(modelRoot);
// Create GUI components
factory = new GUIComponentFactoryImpl(modelRoot, actionRoot);
JFrame createClientJFrame = factory.createClientJFrame(name);
screenHandler = new ScreenHandler(createClientJFrame, screenMode, dm);
}
@Override
protected void clientUpdates() {
if (factory.isSetup()) {
factory.getBuildTrackController().update();
// Update sub tick time.
long currentTime = System.currentTimeMillis();
long lastTick = getLastTickTime();
double dt = currentTime - lastTick;
ReadOnlyWorld world2 = modelRoot.getWorld();
GameSpeed gameSpeed = (GameSpeed) world2.get(ITEM.GAME_SPEED);
GameTime currentGameTime = world2.currentTime();
double ticks = currentGameTime.getTicks();
if(!gameSpeed.isPaused()){
double milliSecondsPerTick = 1000/ gameSpeed.getSpeed();
double subTicks = dt / milliSecondsPerTick;
subTicks = Math.min(dt, 1d);
ticks += subTicks;
}
modelRoot.setProperty(Property.TIME, new Double(ticks));
}
}
public void finished() {
// TODO Auto-generated method stub
}
public ScreenHandler getScreenHandler() {
return screenHandler;
}
@Override
protected void newWorld(World w) {
try {
if (null == vl || !vl.validate(w)) {
try {
vl = new RenderersRootImpl(w, monitor);
monitor.finished();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// Should be a smarter way of doing this..
for (int player = 0; player < w.getNumberOfPlayers(); player++) {
Player p = w.getPlayer(player);
if (p.getName().equals(this.name)) {
modelRoot.setup(w, p.getPrincipal());
}
}
modelRoot.setProperty(ModelRoot.Property.SERVER, connection2Server
.getServerDetails());
actionRoot.setup(modelRoot, vl);
factory.setup(vl, w);
} catch (Exception e) {
ReportBugTextGenerator.unexpectedException(e);
}
}
public void nextStep(int max) {
// TODO Auto-generated method stub
}
public void setMessage(String s) {
System.out.println(s);
}
public void setValue(int i) {
// TODO Auto-generated method stub
}
@Override
public void setProperty(ClientProperty propertyName, Serializable value) {
super.setProperty(propertyName, value);
switch (propertyName) {
case SAVED_GAMES:
modelRoot.setProperty(Property.SAVED_GAMES_LIST, value);
break;
default:
break;
}
}
void start() {
// Set up world.
SavedGamesManager gamesManager = new SavedGamesManagerImpl();
FreerailsGameServer server = new FreerailsGameServer(gamesManager);
String mapName = gamesManager.getNewMapNames()[0];
ServerGameModelImpl serverGameModel = new ServerGameModelImpl();
server.setServerGameModel(serverGameModel);
this.connect(server, name, "password");
server.newGame(mapName);
while (null == this.getWorld()) {
this.update();
server.update();
}
GameModel[] models = new GameModel[] { this, server };
// Start the game loop
GameLoop gameLoop = new GameLoop(screenHandler, models);
Thread t = new Thread(gameLoop);
t.start();
}
}

/**
* Launcher GUI for both the server and/or client.
*
* TODO The code in the switch statements needs reviewing.
*
* @author rtuck99@users.sourceforge.net
* @author Luke
*/
public class Launcher extends javax.swing.JFrame implements LauncherInterface {
private static final long serialVersionUID = 1L;
private static final Logger logger = Logger.getLogger(Launcher.class
.getName());
private static String QUICKSTART = "-quickstart";
private final Component[] wizardPages = new Component[4];
private int currentPage = 0;
private FreerailsGameServer server;
private GUIClient client;
private Properties props;
private final ImageIcon errorIcon = new javax.swing.ImageIcon(getClass()
.getResource("/jfreerails/client/graphics/icons/error.gif"));
private final ImageIcon warningIcon = new javax.swing.ImageIcon(getClass()
.getResource("/jfreerails/client/graphics/icons/warning.gif"));
private final ImageIcon infoIcon = new javax.swing.ImageIcon(getClass()
.getResource("/jfreerails/client/graphics/icons/info.gif"));
private final ProgressJPanel progressPanel = new ProgressJPanel(this);
public void setNextEnabled(boolean enabled) {
nextButton.setEnabled(enabled);
if (nextIsStart) {
nextButton.setText("Start");
} else {
nextButton.setText("Next...");
}
}
private boolean nextIsStart = false;
private void startGame() {
CardLayout cl = (CardLayout) jPanel1.getLayout();
cl.show(jPanel1, "4");
setButtonsVisible(false);
LauncherPanel1 lp = (LauncherPanel1) wizardPages[0];
SelectMapJPanel msp = (SelectMapJPanel) wizardPages[1];
ClientOptionsJPanel cop = (ClientOptionsJPanel) wizardPages[2];
ConnectedPlayersJPanel cp = (ConnectedPlayersJPanel) wizardPages[3];
boolean recover = false;
int mode;
switch (lp.getMode()) {
case LauncherPanel1.MODE_SINGLE_PLAYER:
try {
mode = cop.getScreenMode();
client = new GUIClient(cop.getPlayerName(), progressPanel,
mode, cop.getDisplayMode());
if (isNewGame()) {
initServer();
}
client.connect(server, cop.getPlayerName(), "password");
setServerGameModel();
} catch (IOException e) {
setInfoText(e.getMessage(), LauncherInterface.WARNING);
recover = true;
} finally {
if (recover) {
cop.setControlsEnabled(true);
prevButton.setEnabled(true);
setButtonsVisible(true);
currentPage = 1;
cl.show(jPanel1, "1");
return;
}
}
startThread(server, client);
break;
case LauncherPanel1.MODE_START_NETWORK_GAME:
// LL: I don't think this code ever executes now that there is a
// connected players screen.
try {
setServerGameModel();
currentPage = 3;
String[] playerNames = server.getPlayerNames();
playerNames = playerNames.length == 0 ? new String[] { "No players are connected." }
: playerNames;
cp.setListOfPlayers(playerNames);
cl.show(jPanel1, "3");
setNextEnabled(false);
} catch (IOException e) {
// We end up here if an Exception was thrown when loading a
// saved game.
setInfoText(e.getMessage(), LauncherInterface.WARNING);
recover = true;
} finally {
if (recover) {
cop.setControlsEnabled(true);
prevButton.setEnabled(true);
setNextEnabled(true);
currentPage = 1;
setButtonsVisible(true);
cl.show(jPanel1, "1");
return;
}
}
break;
case LauncherPanel1.MODE_JOIN_NETWORK_GAME:
mode = cop.getScreenMode();
try {
InetSocketAddress serverInetAddress = cop
.getRemoteServerAddress();
if (null == serverInetAddress) {
throw new NullPointerException("Couldn't resolve hostname.");
}
String playerName = cop.getPlayerName();
client = new GUIClient(playerName, progressPanel, mode, cop
.getDisplayMode());
String hostname = serverInetAddress.getHostName();
int port = serverInetAddress.getPort();
setInfoText("Connecting to server...", LauncherInterface.INFO);
LogOnResponse logOnResponse = client.connect(hostname, port,
playerName, "password");
if (logOnResponse.isSuccessful()) {
setInfoText("Logged on and waiting for game to start.", LauncherInterface.INFO);
startThread(client);
} else {
recover = true;
setInfoText(logOnResponse.getMessage(),
LauncherInterface.WARNING);
}
} catch (IOException e) {
setInfoText(e.getMessage(), LauncherInterface.WARNING);
recover = true;
} catch (NullPointerException e) {
setInfoText(e.getMessage(), LauncherInterface.WARNING);
recover = true;
} finally {
if (recover) {
cop.setControlsEnabled(true);
prevButton.setEnabled(true);
setButtonsVisible(true);
cl.show(jPanel1, "2");
return;
}
}
break;
case LauncherPanel1.MODE_SERVER_ONLY:
if (msp.validateInput()) {
initServer();
try {
setServerGameModel();
prepare2HostNetworkGame(msp.getServerPort());
setNextEnabled(true);
} catch (NullPointerException e) {
setInfoText(e.getMessage(), LauncherInterface.WARNING);
recover = true;
} catch (IOException e) {
setInfoText(e.getMessage(), LauncherInterface.WARNING);
recover = true;
} finally {
if (recover) {
cop.setControlsEnabled(true);
prevButton.setEnabled(true);
setButtonsVisible(true);
return;
}
}
}
}// End of switch statement
}
private void setServerGameModel() throws IOException {
ClientOptionsJPanel cop = (ClientOptionsJPanel) wizardPages[2];
if (isNewGame()) {
SelectMapJPanel msp2 = (SelectMapJPanel) wizardPages[1];
server.newGame(msp2.getNewMapName());
cop.limitPlayerNames(null);
} else {
// Do nothing since the server is already set up.
}
}
private boolean isNewGame() {
SelectMapJPanel msp2 = (SelectMapJPanel) wizardPages[1];
return msp2.getSelection().equals(SelectMapJPanel.Selection.NEW_GAME);
}
/** Starts the client and server in the same thread. */
private static void startThread(final FreerailsGameServer server,
final GUIClient client) {
try {
Runnable run = new Runnable() {
public void run() {
while (null == client.getWorld()) {
client.update();
server.update();
}
GameModel[] models = new GameModel[] { client, server };
ScreenHandler screenHandler = client.getScreenHandler();
GameLoop gameLoop = new GameLoop(screenHandler, models);
//screenHandler.apply();
gameLoop.run();
}
};
Thread t = new Thread(run, "Client + server main loop");
t.start();
} catch (Exception e) {
exit(e);
}
}
/** Starts the client in a new thread. */
private void startThread(final GUIClient guiClient) {
try {
Runnable run = new Runnable() {
public void run() {
while (null == guiClient.getWorld()) {
guiClient.update();
try {
Thread.sleep(20);
} catch (InterruptedException e) {
// do nothing
}
}
GameModel[] models = new GameModel[] { guiClient };
ScreenHandler screenHandler = guiClient.getScreenHandler();
GameLoop gameLoop = new GameLoop(screenHandler, models);
gameLoop.run();
}
};
Thread t = new Thread(run, "Client main loop");
t.start();
} catch (Exception e) {
exit(e);
}
}
/** Starts the server in a new thread. */
private static void startThread(final FreerailsGameServer server) {
try {
Runnable r = new Runnable() {
public void run() {
while (true) {
long startTime = System.currentTimeMillis();
server.update();
long deltatime = System.currentTimeMillis() - startTime;
if (deltatime < 20) {
try {
Thread.sleep(20 - deltatime);
} catch (InterruptedException e) {
// do nothing.
}
}
}
}
};
Thread t = new Thread(r, "FreerailsGameServer");
t.start();
} catch (Exception e) {
exit(e);
}
}
private void initServer() {
SavedGamesManager gamesManager = new SavedGamesManagerImpl();
server = new FreerailsGameServer(gamesManager);
ServerGameModelImpl serverGameModel = new ServerGameModelImpl();
server.setServerGameModel(serverGameModel);
/*
* Set the server field on the connected players panel so that it can
* keep track of who is connected.
*/
ConnectedPlayersJPanel cp = (ConnectedPlayersJPanel) wizardPages[3];
cp.server = server;
server.addPropertyChangeListener(cp);
cp.updateListOfPlayers();
}
/**
* Runs the game.
*/
public static void main(String args[]) {
//SynchronizedEventQueue.use();
// Let the user know if we are using a custom logging config.
String loggingProperties = System
.getProperty("java.util.logging.config.file");
if (null != loggingProperties) {
logger.info("Logging properties file: " + loggingProperties);
}
logger.fine("Started launcher.");
boolean quickstart = false;
if (args.length > 0) {
for (int i = 0; i < args.length; i++) {
if (QUICKSTART.equals(args[i]))
quickstart = true;
}
}
Launcher launcher = new Launcher(quickstart);
launcher.start(quickstart);
}
/**
* Shows GUI. If <code>quickstart</code> is <code>true</code> runs the
* game.
*
* @param quickstart
* boolean
*/
public void start(boolean quickstart) {
setVisible(true);
if (quickstart) {
startGame();
}
}
/** Starts a thread listening for new connections. */
private void prepare2HostNetworkGame(int port) throws IOException {
loadProps();
if (isNewGame()) {
initServer();
}
InetConnectionAccepter accepter = new InetConnectionAccepter(port,
server);
/*
* Note, the thread's name gets set in the run method so there is no
* point setting it here.
*/
Thread t = new Thread(accepter);
t.start();
CardLayout cl = (CardLayout) jPanel1.getLayout();
cl.show(jPanel1, "3");
currentPage = 3;
}
public Launcher(boolean quickstart) {
loadProps();
initComponents();
wizardPages[0] = new LauncherPanel1(this);
wizardPages[1] = new SelectMapJPanel(this);
wizardPages[2] = new ClientOptionsJPanel(this);
wizardPages[3] = new ConnectedPlayersJPanel();
if (!quickstart) {
jPanel1.add(wizardPages[0], "0");
jPanel1.add(wizardPages[1], "1");
jPanel1.add(wizardPages[2], "2");
jPanel1.add(wizardPages[3], "3");
jPanel1.add(progressPanel, "4");
pack();
} else {
prevButton.setVisible(false);
nextButton.setVisible(false);
pack();
}
hideAllMessages();
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
private void initComponents() {// GEN-BEGIN:initComponents
java.awt.GridBagConstraints gridBagConstraints;
jPanel1 = new javax.swing.JPanel();
nextButton = new javax.swing.JButton();
prevButton = new javax.swing.JButton();
infoLabel = new javax.swing.JLabel();
getContentPane().setLayout(new java.awt.GridBagLayout());
setTitle("Freerails Launcher");
addWindowListener(new java.awt.event.WindowAdapter() {
@Override
public void windowClosing(java.awt.event.WindowEvent evt) {
exitForm(evt);
}
});
jPanel1.setLayout(new java.awt.CardLayout());
jPanel1.setPreferredSize(new java.awt.Dimension(400, 300));
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.gridwidth = 2;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
getContentPane().add(jPanel1, gridBagConstraints);
nextButton.setText("Next...");
nextButton.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
nextButtonActionPerformed(evt);
}
});
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 1;
gridBagConstraints.gridy = 2;
gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
getContentPane().add(nextButton, gridBagConstraints);
prevButton.setText("Back...");
prevButton.setEnabled(false);
prevButton.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
prevButtonActionPerformed(evt);
}
});
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 2;
gridBagConstraints.anchor = java.awt.GridBagConstraints.EAST;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
getContentPane().add(prevButton, gridBagConstraints);
infoLabel.setText("Error messages go here!");
infoLabel.setVerticalAlignment(javax.swing.SwingConstants.TOP);
infoLabel.setMinimumSize(new java.awt.Dimension(20, 20));
infoLabel.setPreferredSize(new java.awt.Dimension(20, 20));
infoLabel.setVerifyInputWhenFocusTarget(false);
infoLabel.setVerticalTextPosition(javax.swing.SwingConstants.TOP);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 0;
gridBagConstraints.gridwidth = 2;
gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.insets = new java.awt.Insets(4, 4, 4, 4);
getContentPane().add(infoLabel, gridBagConstraints);
pack();
}// GEN-END:initComponents
private void prevButtonActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_prevButtonActionPerformed
CardLayout cl = (CardLayout) jPanel1.getLayout();
nextIsStart = false;
hideAllMessages();
switch (currentPage) {
case 1:
cl.previous(jPanel1);
currentPage--;
prevButton.setEnabled(false);
break;
case 2:
LauncherPanel1 panel = (LauncherPanel1) wizardPages[0];
if (panel.getMode() == LauncherPanel1.MODE_JOIN_NETWORK_GAME) {
currentPage = 0;
cl.show(jPanel1, "0");
prevButton.setEnabled(false);
} else {
currentPage--;
cl.previous(jPanel1);
}
}
}// GEN-LAST:event_prevButtonActionPerformed
private void nextButtonActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_nextButtonActionPerformed
try {
CardLayout cl = (CardLayout) jPanel1.getLayout();
LauncherPanel1 panel = (LauncherPanel1) wizardPages[0];
SelectMapJPanel msp = (SelectMapJPanel) wizardPages[1];
ClientOptionsJPanel cop = (ClientOptionsJPanel) wizardPages[2];
hideAllMessages();
switch (currentPage) {
case 0:
msp.validateInput();
/* Initial game selection page */
switch (panel.getMode()) {
case LauncherPanel1.MODE_SERVER_ONLY:
/* go to map selection screen */
cl.next(jPanel1);
msp.setServerPortPanelVisible(true);
currentPage++;
break;
case LauncherPanel1.MODE_SINGLE_PLAYER:
/* go to map selection screen */
cl.next(jPanel1);
msp.setServerPortPanelVisible(false);
cop.setRemoteServerPanelVisible(false);
currentPage++;
break;
case LauncherPanel1.MODE_START_NETWORK_GAME:
/* go to map selection screen */
msp.setServerPortPanelVisible(true);
cop.setRemoteServerPanelVisible(false);
cl.next(jPanel1);
currentPage++;
break;
case LauncherPanel1.MODE_JOIN_NETWORK_GAME:
/* client display options */
nextIsStart = true;
cl.show(jPanel1, "2");
currentPage = 2;
msp.setServerPortPanelVisible(false);
cop.setRemoteServerPanelVisible(true);
cop.limitPlayerNames(null);
break;
}
prevButton.setEnabled(true);
break;
case 1:
/* map selection page */
if (panel.getMode() == LauncherPanel1.MODE_SERVER_ONLY) {
if (msp.validateInput()) {
prevButton.setEnabled(false);
try {
if (!isNewGame()) {
initServer();
server
.loadgame(ServerControlInterface.FREERAILS_SAV);
}
prepare2HostNetworkGame(msp.getServerPort());
} catch (BindException be) {
// When the port is already in use.
prevButton.setEnabled(true);
setInfoText(be.getMessage(),
LauncherInterface.WARNING);
}
}
} else {
if (isNewGame()) {
cop.limitPlayerNames(null);
} else {
initServer();
server.loadgame(msp.getSaveGameName());
String[] playernames = server.getPlayerNames();
cop.limitPlayerNames(playernames);
}
nextIsStart = true;
prevButton.setEnabled(true);
setNextEnabled(true);
currentPage++;
cl.next(jPanel1);
}
break;
case 2:
/* display mode selection */
if (panel.getMode() == LauncherPanel1.MODE_START_NETWORK_GAME) {
if (msp.validateInput()) {
prevButton.setEnabled(false);
int mode = cop.getScreenMode();
prepare2HostNetworkGame(msp.getServerPort());
client = new GUIClient(cop.getPlayerName(),
progressPanel, mode, cop.getDisplayMode());
client.connect(server, cop.getPlayerName(), "password");
}
} else {
prevButton.setEnabled(false);
cop.setControlsEnabled(false);
startGame();
}
break;
case 3:
try {
/* Connection status screen */
prevButton.setEnabled(false);
setServerGameModel();// TODO catch exception
if (panel.getMode() == LauncherPanel1.MODE_START_NETWORK_GAME) {
startThread(server, client);
cl.show(jPanel1, "4");
} else {
/* Start a stand alone server. */
startThread(server);
setVisible(false);
}
setButtonsVisible(false);
setNextEnabled(false);
} catch (IOException e) {
setInfoText(e.getMessage(), LauncherInterface.WARNING);
cop.setControlsEnabled(true);
prevButton.setEnabled(true);
setNextEnabled(true);
currentPage = 1;
cl.show(jPanel1, "1");
return;
}
break;
default:
throw new IllegalArgumentException(String.valueOf(currentPage));
}
} catch (Exception e) {
exit(e);
}
}// GEN-LAST:event_nextButtonActionPerformed
private static void exit(Exception e) {
ReportBugTextGenerator.unexpectedException(e);
}
/** Exit the Application. */
private void exitForm(java.awt.event.WindowEvent evt) {// GEN-FIRST:event_exitForm
System.exit(0);
}// GEN-LAST:event_exitForm
// Variables declaration - do not modify//GEN-BEGIN:variables
javax.swing.JLabel infoLabel;
javax.swing.JPanel jPanel1;
javax.swing.JButton nextButton;
javax.swing.JButton prevButton;
// End of variables declaration//GEN-END:variables
public void setInfoText(String text, int status) {
infoLabel.setText(text);
switch (status) {
case LauncherInterface.ERROR:
infoLabel.setIcon(errorIcon);
nextButton.setEnabled(false);
break;
case LauncherInterface.INFO:
infoLabel.setIcon(infoIcon);
nextButton.setEnabled(true);
break;
case LauncherInterface.WARNING:
infoLabel.setIcon(warningIcon);
nextButton.setEnabled(true);
break;
default:
throw new IllegalArgumentException(String.valueOf(status));
}
}
public void hideAllMessages() {
infoLabel.setText(null);
infoLabel.setIcon(null);
nextButton.setEnabled(true);
}
public void setButtonsVisible(boolean b){
nextButton.setVisible(b);
prevButton.setVisible(b);
}
public void hideErrorMessages() {
if (infoLabel.getIcon() == errorIcon) {
infoLabel.setText(null);
infoLabel.setIcon(null);
nextButton.setEnabled(true);
}
}
private void loadProps(){
try{
props = new Properties();
FileInputStream in = new FileInputStream("freerails.properties");
props.load(in);
in.close();
if(!props.containsKey("freerails.server.port") ||
!props.containsKey("freerails.server.port") ||
!props.containsKey("freerails.server.port")){
throw new Exception();
}
}catch (Exception e){
props = new Properties();
props.setProperty("freerails.server.port", "55000");
props.setProperty("freerails.player.name", System.getProperty("user.name"));
props.setProperty("freerails.server.ip.address", "127.0.0.1");
}
}
public void saveProps(){
try{
FileOutputStream out = new FileOutputStream("freerails.properties");
props.store(out, "---No Comment---");
out.close();
//Copy key-value pairs to System.Properties so
//that they are visible in the game via the
//show java properties menu item.
System.getProperties().putAll(props);
}catch (Exception e){
logger.warning(e.getMessage());
}
}
public void setProperty(String key, String value){
props.setProperty(key, value);
}
public String getProperty(String key){
return props.getProperty(key);
}
}

/**
* Exposes the methods on the Launcher that the launcher panels may call.
*
* @author Luke
*
*/
public interface LauncherInterface {
public static final int INFO = 0;
public static final int WARNING = 1;
public static final int ERROR = 2;
void setInfoText(String text, int status);
void setNextEnabled(boolean enabled);
void hideErrorMessages();
void hideAllMessages();
void setProperty(String key, String value);
String getProperty(String key);
void saveProps();
}

/**
* @author Luke
*
*/
public interface LauncherPanel {
boolean validateInput();
}

/**
* The first launcher panel, lets you choose 'single player', 'start network
* game' etc.
*
* @author rtuck99@users.sourceforge.net
*/
final class LauncherPanel1 extends javax.swing.JPanel {
private static final long serialVersionUID = 3257850965422913590L;
static final int MODE_SINGLE_PLAYER = 0;
static final int MODE_START_NETWORK_GAME = 1;
static final int MODE_JOIN_NETWORK_GAME = 2;
static final int MODE_SERVER_ONLY = 3;
private final ButtonModel[] buttonModels = new ButtonModel[4];
int getMode() {
for (int i = 0; i < buttonModels.length; i++) {
if (buttonGroup1.getSelection() == buttonModels[i]) {
return i;
}
}
assert false;
return 0;
}
/*
* private void validateSettings() { boolean isValid = false; String
* infoText = null;
*
* switch (getMode()) {
*
* case MODE_SINGLE_PLAYER: isValid = true; break; case
* MODE_START_NETWORK_GAME: case MODE_SERVER_ONLY: isValid = true; break;
* case MODE_JOIN_NETWORK_GAME: isValid = true; break; }
* owner.setInfoText(infoText, LauncherInterface.WARNING);
* owner.setNextEnabled(isValid); }
*/
public LauncherPanel1(LauncherInterface owner) {
initComponents();
buttonModels[MODE_SINGLE_PLAYER] = singlePlayerButton.getModel();
buttonModels[MODE_START_NETWORK_GAME] = startNetworkButton.getModel();
buttonModels[MODE_JOIN_NETWORK_GAME] = joinNetworkButton.getModel();
buttonModels[MODE_SERVER_ONLY] = serverOnlyButton.getModel();
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
private void initComponents() {// GEN-BEGIN:initComponents
java.awt.GridBagConstraints gridBagConstraints;
buttonGroup1 = new javax.swing.ButtonGroup();
singlePlayerButton = new javax.swing.JRadioButton();
startNetworkButton = new javax.swing.JRadioButton();
joinNetworkButton = new javax.swing.JRadioButton();
serverOnlyButton = new javax.swing.JRadioButton();
paddingJPanel = new javax.swing.JPanel();
setLayout(new java.awt.GridBagLayout());
setBorder(new javax.swing.border.TitledBorder(
new javax.swing.border.EtchedBorder(), "Select Game Type"));
buttonGroup1.add(singlePlayerButton);
singlePlayerButton.setSelected(true);
singlePlayerButton.setText("Single-Player");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
gridBagConstraints.weightx = 1.0;
add(singlePlayerButton, gridBagConstraints);
buttonGroup1.add(startNetworkButton);
startNetworkButton.setText("Start a network game");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
gridBagConstraints.weightx = 1.0;
add(startNetworkButton, gridBagConstraints);
buttonGroup1.add(joinNetworkButton);
joinNetworkButton.setText("Join a network game");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
gridBagConstraints.weightx = 1.0;
add(joinNetworkButton, gridBagConstraints);
buttonGroup1.add(serverOnlyButton);
serverOnlyButton.setText("Server only");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTHWEST;
gridBagConstraints.weightx = 1.0;
add(serverOnlyButton, gridBagConstraints);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 4;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
add(paddingJPanel, gridBagConstraints);
}// GEN-END:initComponents
// Variables declaration - do not modify//GEN-BEGIN:variables
javax.swing.ButtonGroup buttonGroup1;
javax.swing.JRadioButton joinNetworkButton;
javax.swing.JPanel paddingJPanel;
javax.swing.JRadioButton serverOnlyButton;
javax.swing.JRadioButton singlePlayerButton;
javax.swing.JRadioButton startNetworkButton;
// End of variables declaration//GEN-END:variables
}

/**
* A JPanel that displays a splash screen and a progress bar.
*
* @author Luke
*/
public class ProgressJPanel extends javax.swing.JPanel implements
FreerailsProgressMonitor{
private static final long serialVersionUID = 3256445798203273776L;
int step, stepSize;
final int numSteps = 5;
LauncherInterface owner;
public void setValue(int i) {
int value = i * 100 / stepSize;
value += 100 * step;
progressBar.setValue(value);
}
public void nextStep(int max) {
//So that the waiting for game to start message
//goes away.
owner.hideAllMessages();
step++;
stepSize = max;
if(numSteps < step)
throw new IllegalStateException();
}
public void finished() {
if(numSteps-1 != step)
throw new IllegalStateException(numSteps +"!="+ step);
getTopLevelAncestor().setVisible(false);
}
/** Creates new form ProgressJPanel */
public ProgressJPanel(LauncherInterface owner) {
this.owner = owner;
initComponents();
progressBar.setMaximum(numSteps * 100);
}
/** This method is called from within the constructor to
* initialize the form.
* WARNING: Do NOT modify this code. The content of this method is
* always regenerated by the Form Editor.
*/
// <editor-fold defaultstate="collapsed" desc=" Generated Code ">//GEN-BEGIN:initComponents
private void initComponents() {
java.awt.GridBagConstraints gridBagConstraints;
progressBar = new javax.swing.JProgressBar();
splashImage = new javax.swing.JLabel();
setLayout(new java.awt.GridBagLayout());
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
gridBagConstraints.insets = new java.awt.Insets(3, 7, 3, 7);
add(progressBar, gridBagConstraints);
splashImage.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
splashImage.setIcon(new javax.swing.ImageIcon(getClass().getResource("/jfreerails/client/graphics/splash_screen.jpg")));
add(splashImage, new java.awt.GridBagConstraints());
}
// </editor-fold>//GEN-END:initComponents
// Variables declaration - do not modify//GEN-BEGIN:variables
javax.swing.JProgressBar progressBar;
javax.swing.JLabel splashImage;
// End of variables declaration//GEN-END:variables
}

/**
* The Launcher panel that lets you load a game or start a new game with a
* choice of maps.
* @author Luke
*/
public class SelectMapJPanel extends javax.swing.JPanel implements LauncherPanel {
private static final long serialVersionUID = 3763096353857024568L;
private static final String SELECT_A_MAP = "Select a map.";
private static final String INVALID_PORT = "A valid port value is between between 0 and 65535.";
private final LauncherInterface owner;
public enum Selection {NONE, NEW_GAME, LOAD_GAME};
Selection getSelection() {
if( newmapsJList.getSelectedIndex() != -1 ){
savedmapsJList.setSelectedIndex(-1);
return Selection.NEW_GAME;
}
if(savedmapsJList.getSelectedIndex() != -1){
return Selection.LOAD_GAME;
}
return Selection.NONE;
}
void setServerPortPanelVisible(boolean b) {
this.jPanel3.setVisible(b);
}
public String getNewMapName() {
return (String) newmapsJList.getSelectedValue();
}
public String getSaveGameName() {
return (String) savedmapsJList.getSelectedValue();
}
SelectMapJPanel(LauncherInterface owner) {
this.owner = owner;
initComponents();
/* initialise the map list */
SavedGamesManagerImpl sgm = new SavedGamesManagerImpl();
newmapsJList.setListData(sgm.getNewMapNames());
newmapsJList.setSelectedIndex(0);
savedmapsJList.setListData(sgm.getSaveGameNames());
owner.setNextEnabled(true);
// Listen for changes in the server port text box.
serverPort.getDocument().addDocumentListener(new DocumentListener() {
public void insertUpdate(DocumentEvent e) {
validateInput();
}
public void removeUpdate(DocumentEvent e) {
validateInput();
}
public void changedUpdate(DocumentEvent e) {
validateInput();
}
});
}
int getServerPort() {
String s = serverPort.getText();
return Integer.parseInt(s);
}
public boolean validateInput() {
/* Validate map selection. */
if (this.getSelection().equals(Selection.NONE)) {
owner.setInfoText(SELECT_A_MAP, LauncherInterface.ERROR);
return false;
}
/* Validate port. */
try {
int port = getServerPort();
if (port < 0 || port > 65535) {
owner.setInfoText(INVALID_PORT, LauncherInterface.ERROR);
return false;
}
} catch (Exception e) {
owner.setInfoText(INVALID_PORT, LauncherInterface.ERROR);
return false;
}
/* Everything is ok. */
owner.hideErrorMessages();
owner.setProperty("freerails.server.port", this.serverPort.getText());
owner.saveProps();
return true;
}
/** This method is called from within the constructor to
* initialize the form.
* WARNING: Do NOT modify this code. The content of this method is
* always regenerated by the Form Editor.
*/
// <editor-fold defaultstate="collapsed" desc=" Generated Code ">//GEN-BEGIN:initComponents
private void initComponents() {
java.awt.GridBagConstraints gridBagConstraints;
jPanel1 = new javax.swing.JPanel();
jScrollPane1 = new javax.swing.JScrollPane();
newmapsJList = new javax.swing.JList();
jPanel4 = new javax.swing.JPanel();
jScrollPane2 = new javax.swing.JScrollPane();
savedmapsJList = new javax.swing.JList();
jPanel3 = new javax.swing.JPanel();
portLabel = new javax.swing.JLabel();
serverPort = new javax.swing.JTextField();
jPanel2 = new javax.swing.JPanel();
setLayout(new java.awt.GridBagLayout());
jPanel1.setLayout(new java.awt.BorderLayout());
jPanel1.setBorder(new javax.swing.border.TitledBorder(new javax.swing.border.EtchedBorder(), "New Game"));
jPanel1.setPreferredSize(null);
jScrollPane1.setViewportBorder(new javax.swing.border.BevelBorder(javax.swing.border.BevelBorder.LOWERED));
newmapsJList.setSelectionMode(javax.swing.ListSelectionModel.SINGLE_SELECTION);
newmapsJList.addListSelectionListener(new javax.swing.event.ListSelectionListener() {
public void valueChanged(javax.swing.event.ListSelectionEvent evt) {
newmapsJListValueChanged(evt);
}
});
jScrollPane1.setViewportView(newmapsJList);
jPanel1.add(jScrollPane1, java.awt.BorderLayout.CENTER);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
add(jPanel1, gridBagConstraints);
jPanel4.setLayout(new java.awt.BorderLayout());
jPanel4.setBorder(new javax.swing.border.TitledBorder(new javax.swing.border.EtchedBorder(), "Load game"));
jPanel4.setPreferredSize(null);
jPanel4.setRequestFocusEnabled(false);
jScrollPane2.setViewportBorder(new javax.swing.border.BevelBorder(javax.swing.border.BevelBorder.LOWERED));
savedmapsJList.setSelectionMode(javax.swing.ListSelectionModel.SINGLE_SELECTION);
savedmapsJList.addListSelectionListener(new javax.swing.event.ListSelectionListener() {
public void valueChanged(javax.swing.event.ListSelectionEvent evt) {
savedmapsJListValueChanged(evt);
}
});
jScrollPane2.setViewportView(savedmapsJList);
jPanel4.add(jScrollPane2, java.awt.BorderLayout.CENTER);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 1;
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
gridBagConstraints.weighty = 1.0;
add(jPanel4, gridBagConstraints);
jPanel3.setLayout(new java.awt.GridBagLayout());
jPanel3.setBorder(new javax.swing.border.TitledBorder(new javax.swing.border.EtchedBorder(), "Server port"));
portLabel.setText("Port:");
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 0;
gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
jPanel3.add(portLabel, gridBagConstraints);
serverPort.setColumns(6);
serverPort.setText( owner.getProperty("freerails.server.port"));
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 1;
gridBagConstraints.gridy = 0;
gridBagConstraints.anchor = java.awt.GridBagConstraints.WEST;
jPanel3.add(serverPort, gridBagConstraints);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.fill = java.awt.GridBagConstraints.BOTH;
gridBagConstraints.weightx = 1.0;
jPanel3.add(jPanel2, gridBagConstraints);
gridBagConstraints = new java.awt.GridBagConstraints();
gridBagConstraints.gridx = 0;
gridBagConstraints.gridy = 2;
gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
add(jPanel3, gridBagConstraints);
}
// </editor-fold>//GEN-END:initComponents
private void savedmapsJListValueChanged(javax.swing.event.ListSelectionEvent evt) {//GEN-FIRST:event_savedmapsJListValueChanged
if(savedmapsJList.getSelectedIndex() != -1)
newmapsJList.clearSelection();
validateInput();
}//GEN-LAST:event_savedmapsJListValueChanged
private void newmapsJListValueChanged(javax.swing.event.ListSelectionEvent evt) {//GEN-FIRST:event_newmapsJListValueChanged
if(newmapsJList.getSelectedIndex() != -1)
savedmapsJList.clearSelection();
validateInput();
}//GEN-LAST:event_newmapsJListValueChanged
// Variables declaration - do not modify//GEN-BEGIN:variables
javax.swing.JPanel jPanel1;
javax.swing.JPanel jPanel2;
javax.swing.JPanel jPanel3;
javax.swing.JPanel jPanel4;
javax.swing.JScrollPane jScrollPane1;
javax.swing.JScrollPane jScrollPane2;
javax.swing.JList newmapsJList;
javax.swing.JLabel portLabel;
javax.swing.JList savedmapsJList;
javax.swing.JTextField serverPort;
// End of variables declaration//GEN-END:variables
}

/**
* All TestCases for moves should extend this class.
*
* @author Luke
*
*/
public abstract class AbstractMoveTestCase extends TestCase {
private boolean hasSetupBeenCalled = false;
protected World world;
protected AbstractMoveTestCase() {
}
public AbstractMoveTestCase(String str) {
super(str);
}
protected void assertDoMoveFails(Move m) {
assertSetupHasBeenCalled();
MoveStatus ms = m.doMove(getWorld(), Player.AUTHORITATIVE);
assertNotNull(ms);
assertTrue("Move went through when it should have failed", !ms.ok);
}
protected void assertDoMoveIsOk(Move m) {
assertSetupHasBeenCalled();
MoveStatus ms = m.doMove(getWorld(), Player.AUTHORITATIVE);
assertNotNull(ms);
assertEquals(MoveStatus.MOVE_OK, ms);
}
protected void assertDoThenUndoLeavesWorldUnchanged(Move m) {
try {
World w = getWorld();
World before = (World) Utils.cloneBySerialisation(w);
assertEquals(before, w);
assertTrue(m.doMove(w, Player.AUTHORITATIVE).ok);
World after = (World) Utils.cloneBySerialisation(w);
assertFalse(after.equals(before));
boolean b = m.undoMove(w, Player.AUTHORITATIVE).ok;
assertTrue(b);
assertEquals(before, w);
} catch (Exception e) {
e.printStackTrace();
assertTrue(false);
}
}
/**
* This method asserts that if we serialise then deserialize the specified
* move, the specified move is equal to the deserialized move. The assertion
* depends on the move being serializable and the equals method being
* implemented correctly. Also checks that the hashcode does not change.
*
* @param m
*/
protected void assertSurvivesSerialisation(FreerailsSerializable m) {
assertEquals("Reflexivity violated: the move does not equal itself", m,
m);
try {
Object o = Utils.cloneBySerialisation(m);
assertEquals(m, o);
assertEquals("The hashcodes should be the same!", m.hashCode(), o
.hashCode());
} catch (Exception e) {
e.printStackTrace();
assertTrue(false);
}
}
protected void assertOkAndRepeatable(Move m) {
assertSetupHasBeenCalled();
// Do move
assertTryMoveIsOk(m);
assertDoMoveIsOk(m);
assertTryMoveIsOk(m);
assertDoMoveIsOk(m);
// Since it leaves the world unchanged it should also be
// possible to undo it repeatably
assertTryUndoMoveIsOk(m);
assertUndoMoveIsOk(m);
assertTryUndoMoveIsOk(m);
assertUndoMoveIsOk(m);
}
/**
* Generally moves should not be repeatable. For example, if we have just
* removed a piece of track, that piece of track is gone, so we cannot
* remove it again.
*/
protected void assertOkButNotRepeatable(Move m) {
assertSetupHasBeenCalled();
assertTryMoveIsOk(m);
assertDoMoveIsOk(m);
assertTryMoveFails(m);
assertDoMoveFails(m);
assertTryUndoMoveIsOk(m);
assertUndoMoveIsOk(m);
assertTryUndoMoveFails(m);
assertTryMoveIsOk(m);
assertDoMoveIsOk(m);
}
private void assertSetupHasBeenCalled() {
assertTrue("AbstractMoveTestCase.setUp has not been called!",
hasSetupBeenCalled());
}
protected void assertTryMoveFails(Move m) {
assertSetupHasBeenCalled();
MoveStatus ms = m.tryDoMove(getWorld(), Player.AUTHORITATIVE);
assertNotNull(ms);
assertTrue("Move went through when it should have failed", !ms.ok);
}
protected void assertTryMoveIsOk(Move m) {
assertSetupHasBeenCalled();
MoveStatus ms = m.tryDoMove(getWorld(), Player.AUTHORITATIVE);
assertNotNull(ms);
assertEquals("First try failed", MoveStatus.MOVE_OK, ms);
ms = m.tryDoMove(getWorld(), Player.AUTHORITATIVE);
assertNotNull(ms);
assertEquals(
"Second try failed, this suggests that the tryDoMove method failed to leave the world unchanged!",
MoveStatus.MOVE_OK, ms);
}
protected void assertTryUndoMoveFails(Move m) {
assertSetupHasBeenCalled();
MoveStatus ms = m.tryUndoMove(getWorld(), Player.AUTHORITATIVE);
assertNotNull(ms);
assertTrue("Move went through when it should have failed", !ms.ok);
}
protected void assertTryUndoMoveIsOk(Move m) {
assertSetupHasBeenCalled();
MoveStatus ms = m.tryUndoMove(getWorld(), Player.AUTHORITATIVE);
assertNotNull(ms);
assertEquals("First try failed", MoveStatus.MOVE_OK, ms);
ms = m.tryUndoMove(getWorld(), Player.AUTHORITATIVE);
assertNotNull(ms);
assertEquals(
"Second try failed, this suggests that the tryDoMove method failed to leave the world unchanged!",
MoveStatus.MOVE_OK, ms);
}
protected void assertUndoMoveFails(Move m) {
assertSetupHasBeenCalled();
MoveStatus ms = m.tryUndoMove(getWorld(), Player.AUTHORITATIVE);
assertNotNull(ms);
assertTrue("Move went through when it should have failed", !ms.ok);
}
protected void assertUndoMoveIsOk(Move m) {
assertSetupHasBeenCalled();
MoveStatus ms = m.undoMove(getWorld(), Player.AUTHORITATIVE);
assertNotNull(ms);
assertEquals(MoveStatus.MOVE_OK, ms);
}
FreerailsPrincipal getPrincipal() {
return world.getPlayer(0).getPrincipal();
}
World getWorld() {
return world;
}
protected boolean hasSetupBeenCalled() {
return hasSetupBeenCalled;
}
protected void setHasSetupBeenCalled(boolean hasSetupBeenCalled) {
this.hasSetupBeenCalled = hasSetupBeenCalled;
}
@Override
protected void setUp() throws Exception {
setHasSetupBeenCalled(true);
setupWorld();
}
protected void setupWorld() {
setWorld(new WorldImpl(10, 10));
// Set the time..
getWorld().set(ITEM.CALENDAR, new GameCalendar(12000, 1840));
getWorld().addPlayer(MapFixtureFactory.TEST_PLAYER);
}
void setWorld(World world) {
this.world = world;
}
public void testMove(){}
protected void assertTrackHere(int x, int y) {
FreerailsTile tile = (FreerailsTile) world.getTile(x, y);
assertTrue(tile.hasTrack());
}
protected void assertTrackHere(PathOnTiles path) {
ImPoint start = path.getStart();
int x = start.x;
int y = start.y;
for (int i = 0; i < path.steps(); i++) {
assertTrackHere(x, y);
Step step = path.getStep(i);
x += step.deltaX;
y += step.deltaY;
assertTrackHere(x, y);
}
}
}

/**
* A move that adds an active entity. An active entity is something whose state
* may be continually changing. An example is a train - it is an active entity
* since while it is moving its position is continually changing.
*
* @author Luke
* @see NextActivityMove
*/
public class AddActiveEntityMove implements Move {
private static final long serialVersionUID = 8732702087937675013L;
private final Activity activity;
private final FreerailsPrincipal principal;
private final int index;
public AddActiveEntityMove(Activity activity, int index,
FreerailsPrincipal principal) {
this.activity = activity;
this.index = index;
this.principal = principal;
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (!(o instanceof AddActiveEntityMove))
return false;
final AddActiveEntityMove addActiveEntityMove = (AddActiveEntityMove) o;
if (index != addActiveEntityMove.index)
return false;
if (!activity.equals(addActiveEntityMove.activity))
return false;
if (!principal.equals(addActiveEntityMove.principal))
return false;
return true;
}
@Override
public int hashCode() {
int result;
result = activity.hashCode();
result = 29 * result + principal.hashCode();
result = 29 * result + index;
return result;
}
public MoveStatus tryDoMove(World w, FreerailsPrincipal p) {
if (index != w.size(principal))
return MoveStatus.moveFailed("index != w.size(listKey, p)");
return MoveStatus.MOVE_OK;
}
public MoveStatus tryUndoMove(World w, FreerailsPrincipal p) {
int expectedSize = index + 1;
if (expectedSize != w.size(principal))
return MoveStatus
.moveFailed("(index + 1) != w.size(listKey, principal)");
ActivityIterator ai = w.getActivities(principal, index);
if (ai.hasNext())
return MoveStatus
.moveFailed("There should be exactly one activity!");
Activity act = ai.getActivity();
if (!act.equals(activity))
return MoveStatus.moveFailed("Expected " + activity.toString()
+ " but found " + act.toString());
return MoveStatus.MOVE_OK;
}
public MoveStatus doMove(World w, FreerailsPrincipal p) {
MoveStatus ms = tryDoMove(w, p);
if (ms.ok)
w.addActiveEntity(principal, activity);
return ms;
}
public MoveStatus undoMove(World w, FreerailsPrincipal p) {
MoveStatus ms = tryUndoMove(w, p);
if (ms.ok)
w.removeLastActiveEntity(principal);
return ms;
}
}

/**
* This Move adds a cargo bundle to the cargo bundle list.
*
* @author Luke
*
*/
public class AddCargoBundleMove extends AddItemToListMove {
private static final long serialVersionUID = 3257288049795674934L;
public AddCargoBundleMove(int i, ImmutableCargoBundle item,
FreerailsPrincipal p) {
super(KEY.CARGO_BUNDLES, i, item, p);
}
}

/**
* All moves that add an item to a list should extend this class.
*
* @author Luke
*
*/
public class AddItemToListMove implements ListMove {
private static final long serialVersionUID = 3256721779916747824L;
private final KEY listKey;
private final int index;
private final FreerailsPrincipal principal;
private final FreerailsSerializable item;
public int getIndex() {
return index;
}
@Override
public int hashCode() {
int result;
result = listKey.hashCode();
result = 29 * result + index;
result = 29 * result + principal.hashCode();
result = 29 * result + (item != null ? item.hashCode() : 0);
return result;
}
public KEY getKey() {
return listKey;
}
public AddItemToListMove(KEY key, int i, FreerailsSerializable item,
FreerailsPrincipal p) {
this.listKey = key;
this.index = i;
this.item = item;
this.principal = p;
}
public MoveStatus tryDoMove(World w, FreerailsPrincipal p) {
if (w.size(this.principal, listKey) != index) {
return MoveStatus.moveFailed("Expected size of "
+ listKey.toString() + " list is " + index
+ " but actual size is " + w.size(this.principal, listKey));
}
return MoveStatus.MOVE_OK;
}
public MoveStatus tryUndoMove(World w, FreerailsPrincipal p) {
int expectListSize = index + 1;
if (w.size(this.principal, listKey) != expectListSize) {
return MoveStatus.moveFailed("Expected size of "
+ listKey.toString() + " list is " + expectListSize
+ " but actual size is " + w.size(this.principal, listKey));
}
return MoveStatus.MOVE_OK;
}
public MoveStatus doMove(World w, FreerailsPrincipal p) {
MoveStatus ms = tryDoMove(w, p);
if (ms.isOk()) {
w.add(this.principal, listKey, this.item);
}
return ms;
}
public MoveStatus undoMove(World w, FreerailsPrincipal p) {
MoveStatus ms = tryUndoMove(w, p);
if (ms.isOk()) {
w.removeLast(this.principal, listKey);
}
return ms;
}
@Override
public boolean equals(Object o) {
if (o instanceof AddItemToListMove) {
AddItemToListMove test = (AddItemToListMove) o;
if (null == this.item) {
if (null != test.item) {
return false;
}
} else if (!this.item.equals(test.getAfter())) {
return false;
}
if (this.index != test.index) {
return false;
}
if (this.listKey != test.listKey) {
return false;
}
return true;
}
return false;
}
public FreerailsSerializable getBefore() {
return null;
}
public FreerailsSerializable getAfter() {
return item;
}
@Override
public String toString() {
StringBuffer sb = new StringBuffer(this.getClass().getName());
sb.append("\n list=");
sb.append(listKey.toString());
sb.append("\n index =");
sb.append(index);
sb.append("\n item =");
sb.append(item);
return sb.toString();
}
public FreerailsPrincipal getPrincipal() {
return principal;
}
}

/**
* All moves that add an item to a shared list should extend this class.
*
* @author Luke
*
*/
public class AddItemToSharedListMove implements Move {
private static final long serialVersionUID = 3762256352759722807L;
private final SKEY listKey;
private final int index;
private final FreerailsSerializable item;
public int getIndex() {
return index;
}
@Override
public int hashCode() {
int result;
result = listKey.hashCode();
result = 29 * result + index;
result = 29 * result + (item != null ? item.hashCode() : 0);
return result;
}
public SKEY getKey() {
return listKey;
}
protected AddItemToSharedListMove(SKEY key, int i,
FreerailsSerializable item) {
this.listKey = key;
this.index = i;
this.item = item;
}
public MoveStatus tryDoMove(World w, FreerailsPrincipal p) {
if (w.size(listKey) != index) {
return MoveStatus.moveFailed("Expected size of "
+ listKey.toString() + " list is " + index
+ " but actual size is " + w.size(listKey));
}
return MoveStatus.MOVE_OK;
}
public MoveStatus tryUndoMove(World w, FreerailsPrincipal p) {
int expectListSize = index + 1;
if (w.size(listKey) != expectListSize) {
return MoveStatus.moveFailed("Expected size of "
+ listKey.toString() + " list is " + expectListSize
+ " but actual size is " + w.size(listKey));
}
return MoveStatus.MOVE_OK;
}
public MoveStatus doMove(World w, FreerailsPrincipal p) {
MoveStatus ms = tryDoMove(w, p);
if (ms.isOk()) {
w.add(listKey, this.item);
}
return ms;
}
public MoveStatus undoMove(World w, FreerailsPrincipal p) {
MoveStatus ms = tryUndoMove(w, p);
if (ms.isOk()) {
w.removeLast(listKey);
}
return ms;
}
@Override
public boolean equals(Object o) {
if (o instanceof AddItemToSharedListMove) {
AddItemToSharedListMove test = (AddItemToSharedListMove) o;
if (!this.item.equals(test.getAfter())) {
return false;
}
if (this.index != test.index) {
return false;
}
if (this.listKey != test.listKey) {
return false;
}
return true;
}
return false;
}
public FreerailsSerializable getBefore() {
return null;
}
public FreerailsSerializable getAfter() {
return item;
}
@Override
public String toString() {
StringBuffer sb = new StringBuffer(this.getClass().getName());
sb.append("\nlist=");
sb.append(listKey.toString());
sb.append("\n index =");
sb.append(this.index);
sb.append("\n item =");
sb.append(this.item.toString());
return sb.toString();
}
}

/**
* Adds a player to the world.
*
* @author Luke
*/
public class AddPlayerMove implements Move, ServerMove {
private static final long serialVersionUID = 3977580277537322804L;
private final Player player2add;
private AddPlayerMove(Player p) {
player2add = p;
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (!(o instanceof AddPlayerMove))
return false;
final AddPlayerMove addPlayerMove = (AddPlayerMove) o;
if (!player2add.equals(addPlayerMove.player2add))
return false;
return true;
}
@Override
public int hashCode() {
return player2add.hashCode();
}
public static AddPlayerMove generateMove(ReadOnlyWorld w, Player player) {
/**
* create a new player with a corresponding Principal
*/
Player player2add = new Player(player.getName(), w.getNumberOfPlayers());
return new AddPlayerMove(player2add);
}
public MoveStatus tryDoMove(World w, FreerailsPrincipal p) {
if (isAlreadyASimilarPlayer(w))
return MoveStatus
.moveFailed("There is already a player with the same name.");
return MoveStatus.MOVE_OK;
}
public MoveStatus tryUndoMove(World w, FreerailsPrincipal p) {
int numPlayers = w.getNumberOfPlayers();
Player pp = w.getPlayer(numPlayers - 1);
if (pp.equals(player2add)) {
return MoveStatus.MOVE_OK;
}
return MoveStatus.moveFailed("The last player is " + pp.getName()
+ "not " + player2add.getName());
}
public MoveStatus doMove(World w, FreerailsPrincipal p) {
MoveStatus ms = tryDoMove(w, p);
if (!ms.ok)
return ms;
int playerId = w.addPlayer(this.player2add);
// Sell the player 2 $500,000 bonds at 5% interest.
FreerailsPrincipal principal = player2add.getPrincipal();
w.addTransaction(principal, BondTransaction.issueBond(5));
//Issue stock
Money initialStockPrice = new Money(5);
Transaction t = StockTransaction.issueStock(playerId, 100000,
initialStockPrice);
w.addTransaction(principal, t);
return ms;
}
public MoveStatus undoMove(World w, FreerailsPrincipal p) {
MoveStatus ms = tryUndoMove(w, p);
if (!ms.ok)
return ms;
w.removeLastTransaction(player2add.getPrincipal());
w.removeLastTransaction(player2add.getPrincipal());
w.removeLastPlayer();
return ms;
}
private boolean isAlreadyASimilarPlayer(World w) {
for (int i = 0; i < w.getNumberOfPlayers(); i++) {
Player pp = w.getPlayer(i);
if (pp.getName().equalsIgnoreCase(this.player2add.getName())) {
return true;
}
}
return false;
}
}

/**
* This {@link CompositeMove}adds a station to the station list and adds a
* cargo bundle (to store the cargo waiting at the station) to the cargo bundle
* list.
*
* @author Luke
*
*/
public class AddStationMove extends CompositeMove {
private static final long serialVersionUID = 3256728398461089080L;
private AddStationMove(Move[] moves) {
super(moves);
}
public StationModel getNewStation() {
AddItemToListMove addStation = (AddItemToListMove) super.getMove(2);
return (StationModel) addStation.getAfter();
}
public static AddStationMove generateMove(ReadOnlyWorld w,
String stationName, ImPoint p,
ChangeTrackPieceMove upgradeTrackMove, FreerailsPrincipal principal) {
int cargoBundleNumber = w.size(principal, KEY.CARGO_BUNDLES);
Move addCargoBundleMove = new AddCargoBundleMove(cargoBundleNumber,
ImmutableCargoBundle.EMPTY_BUNDLE, principal);
int stationNumber = w.size(principal, KEY.STATIONS);
StationModel station = new StationModel(p.x, p.y, stationName, w
.size(SKEY.CARGO_TYPES), cargoBundleNumber);
Move addStation = new AddItemToListMove(KEY.STATIONS, stationNumber,
station, principal);
return new AddStationMove(new Move[] { upgradeTrackMove,
addCargoBundleMove, addStation });
}
public static AddStationMove upgradeStation(
ChangeTrackPieceMove upgradeTrackMove) {
return new AddStationMove(new Move[] { upgradeTrackMove });
}
}

/**
* This {@link Move} adds a {@link Transaction} to a players bank account on the
* {@link World} object.
*
* @author Luke Lindsay
*
*/
public class AddTransactionMove implements Move {
private static final long serialVersionUID = 3976738055925019701L;
private final Transaction transaction;
private final FreerailsPrincipal principal;
/** Whether the move fails if there is not enough cash. */
private final boolean constrained;
public Transaction getTransaction() {
return transaction;
}
@Override
public int hashCode() {
int result;
result = transaction.hashCode();
result = 29 * result + principal.hashCode();
result = 29 * result + (constrained ? 1 : 0);
return result;
}
public AddTransactionMove(FreerailsPrincipal account, Transaction t) {
if (null == t) {
throw new NullPointerException();
}
principal = account;
transaction = t;
constrained = false;
}
public AddTransactionMove(FreerailsPrincipal account, Transaction t,
boolean constrain) {
principal = account;
transaction = t;
constrained = constrain;
if (null == t) {
throw new NullPointerException();
}
}
public MoveStatus tryDoMove(World w, FreerailsPrincipal p) {
if (w.isPlayer(principal)) {
if (this.constrained) {
long bankBalance = w.getCurrentBalance(principal).getAmount();
long transactionAmount = this.transaction.deltaCash()
.getAmount();
long balanceAfter = bankBalance + transactionAmount;
if (transactionAmount < 0 && balanceAfter < 0) {
return MoveStatus.moveFailed("You can't afford that!");
}
}
return MoveStatus.MOVE_OK;
}
return MoveStatus.moveFailed(p.getName()
+ " does not have a bank account.");
}
public MoveStatus tryUndoMove(World w, FreerailsPrincipal p) {
int size = w.getNumberOfTransactions(this.principal);
if (0 == size) {
return MoveStatus.moveFailed("No transactions to remove!");
}
Transaction lastTransaction = w
.getTransaction(this.principal, size - 1);
if (lastTransaction.equals(this.transaction)) {
return MoveStatus.MOVE_OK;
}
return MoveStatus.moveFailed("Expected " + this.transaction
+ "but found " + lastTransaction);
}
public MoveStatus doMove(World w, FreerailsPrincipal p) {
MoveStatus ms = tryDoMove(w, p);
if (ms.ok) {
w.addTransaction(this.principal, this.transaction);
}
return ms;
}
public MoveStatus undoMove(World w, FreerailsPrincipal p) {
MoveStatus ms = tryUndoMove(w, p);
if (ms.ok) {
w.removeLastTransaction(this.principal);
}
return ms;
}
@Override
public boolean equals(Object obj) {
if (obj instanceof AddTransactionMove) {
AddTransactionMove test = (AddTransactionMove) obj;
return test.principal.equals(this.principal)
&& test.transaction.equals(this.transaction);
}
return false;
}
public FreerailsPrincipal getPrincipal() {
return principal;
}
}

/**
* This {@link Move} changes a cargo bundle (cargo bundles are used to represent
* the cargo carried by trains and the cargo waiting at stations).
*
* @author Luke
*
*/
public class ChangeCargoBundleMove extends ChangeItemInListMove {
private static final long serialVersionUID = 3258126960072143408L;
public ChangeCargoBundleMove(ImmutableCargoBundle before,
ImmutableCargoBundle after, int bundleNumber, FreerailsPrincipal p) {
super(KEY.CARGO_BUNDLES, bundleNumber, before, after, p);
}
}

/**
*
* Changes the game speed item on the world object.
*
* @author Jan Tozicka
*
*/
public class ChangeGameSpeedMove implements Move {
private static final long serialVersionUID = 3545794368956086071L;
private final GameSpeed oldSpeed;
private final GameSpeed newSpeed;
public static ChangeGameSpeedMove getMove(ReadOnlyWorld w,
GameSpeed newGameSpeed) {
return new ChangeGameSpeedMove((GameSpeed) w.get(ITEM.GAME_SPEED),
newGameSpeed);
}
private ChangeGameSpeedMove(GameSpeed before, GameSpeed after) {
oldSpeed = before;
newSpeed = after;
}
public MoveStatus tryDoMove(World w, FreerailsPrincipal p) {
if (w.get(ITEM.GAME_SPEED).equals(oldSpeed)) {
return MoveStatus.MOVE_OK;
}
String string = "oldSpeed = " + oldSpeed.getSpeed() + " <=> "
+ "currentSpeed "
+ ((GameSpeed) w.get(ITEM.GAME_SPEED)).getSpeed();
return MoveStatus.moveFailed(string);
}
public MoveStatus tryUndoMove(World w, FreerailsPrincipal p) {
GameSpeed speed = ((GameSpeed) w.get(ITEM.GAME_SPEED));
if (speed.equals(newSpeed)) {
return MoveStatus.MOVE_OK;
}
return MoveStatus.moveFailed("Expected " + newSpeed + ", found "
+ speed);
}
public MoveStatus doMove(World w, FreerailsPrincipal p) {
MoveStatus status = tryDoMove(w, p);
if (status.ok) {
w.set(ITEM.GAME_SPEED, newSpeed);
}
return status;
}
public MoveStatus undoMove(World w, FreerailsPrincipal p) {
MoveStatus status = tryUndoMove(w, p);
if (status.isOk()) {
w.set(ITEM.GAME_SPEED, oldSpeed);
}
return status;
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (!(o instanceof ChangeGameSpeedMove))
return false;
final ChangeGameSpeedMove changeGameSpeedMove = (ChangeGameSpeedMove) o;
if (!newSpeed.equals(changeGameSpeedMove.newSpeed))
return false;
if (!oldSpeed.equals(changeGameSpeedMove.oldSpeed))
return false;
return true;
}
@Override
public int hashCode() {
int result;
result = oldSpeed.hashCode();
result = 29 * result + newSpeed.hashCode();
return result;
}
public int getNewSpeed() {
return newSpeed.getSpeed();
}
@Override
public String toString() {
return "ChangeGameSpeedMove: " + oldSpeed + "=>" + newSpeed;
}
}

/**
* All Moves that replace an item in a list with another should extend this
* class.
*
* @author Luke
*
*/
public class ChangeItemInListMove implements ListMove {
private static final long serialVersionUID = -4457694821370844051L;
private final KEY listKey;
private final int index;
private final FreerailsSerializable before;
private final FreerailsSerializable after;
private final FreerailsPrincipal principal;
public ChangeItemInListMove(KEY k, int index, FreerailsSerializable before,
FreerailsSerializable after, FreerailsPrincipal p) {
this.before = before;
this.after = after;
this.index = index;
this.listKey = k;
this.principal = p;
}
public boolean beforeEqualsAfter(){
return Utils.equal(this.before, this.after);
}
public MoveStatus doMove(World w, FreerailsPrincipal p) {
return move(after, before, w);
}
@Override
public boolean equals(Object o) {
if (o instanceof ChangeItemInListMove) {
ChangeItemInListMove test = (ChangeItemInListMove) o;
if (!before.equals(test.getBefore())) {
return false;
}
if (!after.equals(test.getAfter())) {
return false;
}
if (index != test.index) {
return false;
}
if (listKey != test.listKey) {
return false;
}
return true;
}
return false;
}
public FreerailsSerializable getAfter() {
return after;
}
public FreerailsSerializable getBefore() {
return before;
}
public int getIndex() {
return index;
}
public KEY getKey() {
return listKey;
}
public FreerailsPrincipal getPrincipal() {
return principal;
}
@Override
public int hashCode() {
int result;
result = listKey.hashCode();
result = 29 * result + index;
result = 29 * result + (before != null ? before.hashCode() : 0);
result = 29 * result + (after != null ? after.hashCode() : 0);
result = 29 * result + principal.hashCode();
return result;
}
protected MoveStatus move(FreerailsSerializable to,
FreerailsSerializable from, World w) {
MoveStatus ms = tryMove(to, from, w);
if (ms.ok) {
w.set(principal, listKey, index, to);
}
return ms;
}
@Override
public String toString() {
StringBuffer sb = new StringBuffer();
sb.append(getClass().getName());
sb.append(" before: ");
sb.append(before.toString());
sb.append(" after: ");
sb.append(after.toString());
return sb.toString();
}
public MoveStatus tryDoMove(World w, FreerailsPrincipal p) {
return tryMove(after, before, w);
}
protected MoveStatus tryMove(FreerailsSerializable to,
FreerailsSerializable from, World w) {
if (index >= w.size(principal, listKey)) {
return MoveStatus.moveFailed("w.size(listKey) is "
+ w.size(principal, listKey) + " but index is " + index);
}
FreerailsSerializable item2change = w.get(principal, listKey, index);
if (null == item2change) {
if (null == from) {
return MoveStatus.MOVE_OK;
}
return MoveStatus.moveFailed("Expected null but found " + from);
}
if (!from.equals(item2change)) {
String message = "Expected " + from.toString() + " but found "
+ to.toString();
return MoveStatus.moveFailed(message);
}
return MoveStatus.MOVE_OK;
}
public MoveStatus tryUndoMove(World w, FreerailsPrincipal p) {
return tryMove(before, after, w);
}
public MoveStatus undoMove(World w, FreerailsPrincipal p) {
return move(before, after, w);
}
}

/**
* This Move changes what is being built at an engine shop - when a client wants
* to build a train, it should send an instance of this class to the server.
*
* @author Luke
*
*/
public class ChangeProductionAtEngineShopMove implements Move {
private static final long serialVersionUID = 3905519384997737520L;
private final ImList<PlannedTrain> before;
private final ImList<PlannedTrain> after;
private final int stationNumber;
private final FreerailsPrincipal principal;
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (!(o instanceof ChangeProductionAtEngineShopMove))
return false;
final ChangeProductionAtEngineShopMove changeProductionAtEngineShopMove = (ChangeProductionAtEngineShopMove) o;
if (stationNumber != changeProductionAtEngineShopMove.stationNumber)
return false;
if (after != null ? !after
.equals(changeProductionAtEngineShopMove.after)
: changeProductionAtEngineShopMove.after != null)
return false;
if (before != null ? !before
.equals(changeProductionAtEngineShopMove.before)
: changeProductionAtEngineShopMove.before != null)
return false;
if (!principal.equals(changeProductionAtEngineShopMove.principal))
return false;
return true;
}
@Override
public int hashCode() {
int result;
result = (before != null ? before.hashCode() : 0);
result = 29 * result + (after != null ? after.hashCode() : 0);
result = 29 * result + stationNumber;
result = 29 * result + principal.hashCode();
return result;
}
public ChangeProductionAtEngineShopMove(ImList<PlannedTrain> b,
ImList<PlannedTrain> a, int station, FreerailsPrincipal p) {
this.before = b;
this.after = a;
this.stationNumber = station;
this.principal = p;
}
public MoveStatus tryDoMove(World w, FreerailsPrincipal p) {
return tryMove(w, before);
}
private MoveStatus tryMove(World w, ImList<PlannedTrain> stateA) {
// Check that the specified station exists.
if (!w.boundsContain(principal, KEY.STATIONS, this.stationNumber)) {
return MoveStatus.moveFailed(this.stationNumber + " " + principal);
}
StationModel station = (StationModel) w.get(principal, KEY.STATIONS,
stationNumber);
if (null == station) {
return MoveStatus.moveFailed(this.stationNumber + " " + principal
+ " is does null");
}
// Check that the station is building what we expect.
if (null == station.getProduction()) {
if (null == stateA) {
return MoveStatus.MOVE_OK;
}
return MoveStatus.moveFailed(this.stationNumber + " " + principal);
}
if (station.getProduction().equals(stateA)) {
return MoveStatus.MOVE_OK;
}
return MoveStatus.moveFailed(this.stationNumber + " " + principal);
}
public MoveStatus tryUndoMove(World w, FreerailsPrincipal p) {
return tryMove(w, after);
}
public MoveStatus doMove(World w, FreerailsPrincipal p) {
MoveStatus status = tryDoMove(w, p);
if (status.isOk()) {
StationModel station = (StationModel) w.get(principal,
KEY.STATIONS, stationNumber);
station = new StationModel(station, this.after);
w.set(principal, KEY.STATIONS, stationNumber, station);
}
return status;
}
public MoveStatus undoMove(World w, FreerailsPrincipal p) {
MoveStatus status = tryUndoMove(w, p);
if (status.isOk()) {
StationModel station = (StationModel) w.get(principal,
KEY.STATIONS, stationNumber);
station = new StationModel(station, this.before);
w.set(principal, KEY.STATIONS, stationNumber, station);
}
return status;
}
}

/**
*
* This Move changes the properties of a station.
*
* @author lindsal
*/
final public class ChangeStationMove extends ChangeItemInListMove {
private static final long serialVersionUID = 3833469496064160307L;
public ChangeStationMove(int index, StationModel before,
StationModel after, FreerailsPrincipal p) {
super(KEY.STATIONS, index, before, after, p);
}
}

/**
* Move that changes a single tile.
*
* @author Luke
*
*/
public class ChangeTileMove implements Move, MapUpdateMove {
private static final long serialVersionUID = 3256726169272662320L;
private final int x;
private final int y;
private final FreerailsTile before;
private final FreerailsTile after;
public ChangeTileMove(ReadOnlyWorld w, Point p, int terrainTypeAfter) {
this.x = p.x;
this.y = p.y;
this.before = (FreerailsTile) w.getTile(x, y);
this.after = FreerailsTile.getInstance(terrainTypeAfter, before
.getTrackPiece());
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (!(o instanceof ChangeTileMove))
return false;
final ChangeTileMove changeTileMove = (ChangeTileMove) o;
if (x != changeTileMove.x)
return false;
if (y != changeTileMove.y)
return false;
if (!after.equals(changeTileMove.after))
return false;
if (!before.equals(changeTileMove.before))
return false;
return true;
}
@Override
public int hashCode() {
int result;
result = x;
result = 29 * result + y;
result = 29 * result + before.hashCode();
result = 29 * result + after.hashCode();
return result;
}
public MoveStatus tryDoMove(World w, FreerailsPrincipal p) {
FreerailsTile actual = (FreerailsTile) w.getTile(x, y);
TerrainType type = (TerrainType) w.get(SKEY.TERRAIN_TYPES, actual
.getTerrainTypeID());
if (!type.getCategory().equals(TerrainType.Category.Country)) {
return MoveStatus.moveFailed("Can only build on clear terrain.");
}
if (actual.equals(before)) {
return MoveStatus.MOVE_OK;
}
return MoveStatus.moveFailed("Expected " + before + " but found "
+ actual);
}
public MoveStatus tryUndoMove(World w, FreerailsPrincipal p) {
FreerailsTile actual = (FreerailsTile) w.getTile(x, y);
if (actual.equals(after)) {
return MoveStatus.MOVE_OK;
}
return MoveStatus.moveFailed("Expected " + after + " but found "
+ actual);
}
public MoveStatus doMove(World w, FreerailsPrincipal p) {
MoveStatus ms = tryDoMove(w, p);
if (ms.isOk()) {
w.setTile(x, y, after);
}
return ms;
}
public MoveStatus undoMove(World w, FreerailsPrincipal p) {
MoveStatus ms = tryUndoMove(w, p);
if (ms.isOk()) {
w.setTile(x, y, before);
}
return ms;
}
public Rectangle getUpdatedTiles() {
Rectangle r = new Rectangle(x, y, 1, 1);
return r;
}
}

/**
* This Move changes adds, removes, or upgrades the track between two tiles.
*
* @author lindsal
*
*/
public final class ChangeTrackPieceCompositeMove extends CompositeMove
implements TrackMove, MapUpdateMove {
private static final long serialVersionUID = 3616443518780978743L;
private final int x, y, w, h;
private final FreerailsPrincipal builder;
private ChangeTrackPieceCompositeMove(TrackMove a, TrackMove b,
FreerailsPrincipal fp) {
super(a, b);
Rectangle r = a.getUpdatedTiles().union(b.getUpdatedTiles());
x = r.x;
y = r.y;
w = r.width;
h = r.height;
builder = fp;
}
public static ChangeTrackPieceCompositeMove generateBuildTrackMove(
ImPoint from, Step direction, TrackRule ruleA, TrackRule ruleB,
ReadOnlyWorld w, FreerailsPrincipal principal) {
ChangeTrackPieceMove a;
ChangeTrackPieceMove b;
a = getBuildTrackChangeTrackPieceMove(from, direction, ruleA, w,
principal);
b = getBuildTrackChangeTrackPieceMove(direction
.createRelocatedPoint(from), direction.getOpposite(), ruleB, w,
principal);
return new ChangeTrackPieceCompositeMove(a, b, principal);
}
public static ChangeTrackPieceCompositeMove generateRemoveTrackMove(
ImPoint from, Step direction, ReadOnlyWorld w,
FreerailsPrincipal principal) throws Exception {
TrackMove a;
TrackMove b;
a = getRemoveTrackChangeTrackPieceMove(from, direction, w, principal);
b = getRemoveTrackChangeTrackPieceMove(direction
.createRelocatedPoint(from), direction.getOpposite(), w,
principal);
return new ChangeTrackPieceCompositeMove(a, b, principal);
}
// utility method.
private static ChangeTrackPieceMove getBuildTrackChangeTrackPieceMove(
ImPoint p, Step direction, TrackRule trackRule, ReadOnlyWorld w,
FreerailsPrincipal principal) {
TrackPiece oldTrackPiece;
TrackPiece newTrackPiece;
int owner = getOwner(principal, w);
if (w.boundsContain(p.x, p.y)) {
oldTrackPiece = ((FreerailsTile) w.getTile(p.x, p.y))
.getTrackPiece();
if (oldTrackPiece.getTrackRule() != NullTrackType.getInstance()) {
TrackConfiguration trackConfiguration = TrackConfiguration.add(
oldTrackPiece.getTrackConfiguration(), direction);
newTrackPiece = new TrackPieceImpl(trackConfiguration,
oldTrackPiece.getTrackRule(), owner, oldTrackPiece
.getTrackTypeID());
} else {
newTrackPiece = getTrackPieceWhenOldTrackPieceIsNull(direction,
trackRule, owner, findRuleID(trackRule, w));
}
} else {
newTrackPiece = getTrackPieceWhenOldTrackPieceIsNull(direction,
trackRule, owner, findRuleID(trackRule, w));
oldTrackPiece = NullTrackPiece.getInstance();
}
return new ChangeTrackPieceMove(oldTrackPiece, newTrackPiece, p);
}
// utility method.
private static TrackMove getRemoveTrackChangeTrackPieceMove(ImPoint p,
Step direction, ReadOnlyWorld w, FreerailsPrincipal principal)
throws Exception {
TrackPiece oldTrackPiece;
TrackPiece newTrackPiece;
if (w.boundsContain(p.x, p.y)) {
oldTrackPiece = ((FreerailsTile) w.getTile(p.x, p.y)).getTrackPiece();
if (oldTrackPiece.getTrackRule() != NullTrackType.getInstance()) {
TrackConfiguration trackConfiguration = TrackConfiguration
.subtract(oldTrackPiece.getTrackConfiguration(),
direction);
if (trackConfiguration != TrackConfiguration
.getFlatInstance("000010000")) {
int owner = getOwner(principal, w);
newTrackPiece = new TrackPieceImpl(trackConfiguration,
oldTrackPiece.getTrackRule(), owner, oldTrackPiece
.getTrackTypeID());
} else {
newTrackPiece = NullTrackPiece.getInstance();
}
} else {
// There is no track to remove.
// Fix for bug [ 948670 ] Removing non-existent track
throw new Exception();
}
} else {
newTrackPiece = NullTrackPiece.getInstance();
oldTrackPiece = NullTrackPiece.getInstance();
}
ChangeTrackPieceMove m = new ChangeTrackPieceMove(oldTrackPiece,
newTrackPiece, p);
// If we are removing a station, we also need to remove the station from
// the station list.
if (oldTrackPiece.getTrackRule().isStation()
&& !newTrackPiece.getTrackRule().isStation()) {
return RemoveStationMove.getInstance(w, m, principal);
}
return m;
}
private static TrackPiece getTrackPieceWhenOldTrackPieceIsNull(
Step direction, TrackRule trackRule, int owner, int ruleNumber) {
TrackConfiguration simplestConfig = TrackConfiguration
.getFlatInstance("000010000");
TrackConfiguration trackConfiguration = TrackConfiguration.add(
simplestConfig, direction);
return new TrackPieceImpl(trackConfiguration, trackRule, owner,
ruleNumber);
}
public Rectangle getUpdatedTiles() {
return new Rectangle(x, y, w, h);
}
public static int getOwner(FreerailsPrincipal p, ReadOnlyWorld w) {
for (int i = 0; i < w.getNumberOfPlayers(); i++) {
if (w.getPlayer(i).getPrincipal().equals(p)) {
return i;
}
}
throw new IllegalStateException();
}
/** Returns true if some track has been built. */
static boolean hasAnyTrackBeenBuilt(ReadOnlyWorld world,
FreerailsPrincipal principal) {
ItemsTransactionAggregator aggregator = new ItemsTransactionAggregator(
world, principal);
aggregator.setCategory(Transaction.Category.TRACK);
return aggregator.calculateQuantity() > 0;
}
private static boolean mustConnectToExistingTrack(ReadOnlyWorld world) {
GameRules rules = (GameRules) world.get(ITEM.GAME_RULES);
return rules.isMustConnect2ExistingTrack();
}
@Override
protected MoveStatus compositeTest(World world, FreerailsPrincipal p) {
if (mustConnectToExistingTrack(world)) {
if (hasAnyTrackBeenBuilt(world, this.builder)) {
try {
ChangeTrackPieceMove a = (ChangeTrackPieceMove) super
.getMove(0);
ChangeTrackPieceMove b = (ChangeTrackPieceMove) super
.getMove(1);
int ruleBeforeA = a.trackPieceBefore.getTrackTypeID();
int ruleBeforeB = b.trackPieceBefore.getTrackTypeID();
if (ruleBeforeA == NullTrackType.NULL_TRACK_TYPE_RULE_NUMBER
&& ruleBeforeB == NullTrackType.NULL_TRACK_TYPE_RULE_NUMBER) {
return MoveStatus
.moveFailed("Must connect to existing track");
}
} catch (ClassCastException e) {
// It was not the type of move we expected.
// We end up here when we are removing a station.
return MoveStatus.MOVE_OK;
}
}
}
return MoveStatus.MOVE_OK;
}
public static int findRuleID(TrackRule r, ReadOnlyWorld w) {
for (int i = 0; i < w.size(SKEY.TRACK_RULES); i++) {
Object o = w.get(SKEY.TRACK_RULES, i);
if (r.equals(o)) {
return i;
}
}
throw new IllegalStateException();
}
}

/**
* This Move adds, removes, or upgrades the track on a single tile.
*
* @author Luke
*
*/
final public class ChangeTrackPieceMove implements TrackMove, MapUpdateMove {
private static final long serialVersionUID = 4120849958418591801L;
final TrackPiece trackPieceBefore;
private final TrackPiece trackPieceAfter;
private final ImPoint location;
public ImPoint getLocation() {
return location;
}
@Override
public int hashCode() {
int result;
result = (trackPieceBefore != null ? trackPieceBefore.hashCode() : 0);
result = 29 * result
+ (trackPieceAfter != null ? trackPieceAfter.hashCode() : 0);
result = 29 * result + location.hashCode();
return result;
}
public TrackPiece getOldTrackPiece() {
return trackPieceBefore;
}
public TrackPiece getNewTrackPiece() {
return trackPieceAfter;
}
public ChangeTrackPieceMove(TrackPiece before, TrackPiece after, ImPoint p) {
trackPieceBefore = before;
trackPieceAfter = after;
location = p;
}
public MoveStatus tryDoMove(World w, FreerailsPrincipal p) {
return tryMove(w, this.trackPieceBefore, this.trackPieceAfter);
}
private MoveStatus tryMove(World w, TrackPiece oldTrackPiece,
TrackPiece newTrackPiece) {
// Check that location is on the map.
if (!w.boundsContain(location.x, location.y)) {
return MoveStatus
.moveFailed("Tried to build track outside the map.");
}
// Check that we are not changing another players track if this is not
// allowed.
if (!canConnect2OtherRRsTrack(w)) {
// If either the new or old track piece is null, we are ok.
int oldRuleNumber = oldTrackPiece.getTrackTypeID();
int newRuleNumber = newTrackPiece.getTrackTypeID();
if (NullTrackType.NULL_TRACK_TYPE_RULE_NUMBER != oldRuleNumber
&& NullTrackType.NULL_TRACK_TYPE_RULE_NUMBER != newRuleNumber) {
int oldOwner = oldTrackPiece.getOwnerID();
int newOwner = newTrackPiece.getOwnerID();
if (oldOwner != newOwner) {
return MoveStatus
.moveFailed("Not allowed to connect to other RR");
}
}
}
// Check that the current track piece at this.location is
// the same as this.oldTrackPiece.
TrackPiece currentTrackPieceAtLocation = ((FreerailsTile) w.getTile(
location.x, location.y)).getTrackPiece();
TrackRule expectedTrackRule = oldTrackPiece.getTrackRule();
TrackRule actualTrackRule = currentTrackPieceAtLocation.getTrackRule();
if (!expectedTrackRule.equals(actualTrackRule)) {
return MoveStatus.moveFailed("Expected '"
+ expectedTrackRule.getTypeName() + "' but found '"
+ actualTrackRule.getTypeName() + "' at " + location.x
+ " ," + location.y);
}
if (currentTrackPieceAtLocation.getTrackConfiguration() != oldTrackPiece
.getTrackConfiguration()) {
return MoveStatus
.moveFailed("Unexpected track piece found at location: "
+ location.x + " ," + location.y);
}
// Check that oldTrackPiece is not the same as newTrackPiece
if ((oldTrackPiece.getTrackConfiguration() == newTrackPiece
.getTrackConfiguration())
&& (oldTrackPiece.getTrackRule() == newTrackPiece
.getTrackRule())) {
return MoveStatus.moveFailed("Already track here!");
}
// Check for illegal track configurations.
if (!(oldTrackPiece.getTrackRule().trackPieceIsLegal(
oldTrackPiece.getTrackConfiguration()) && newTrackPiece
.getTrackRule().trackPieceIsLegal(
newTrackPiece.getTrackConfiguration()))) {
return MoveStatus.moveFailed("Illegal track configuration.");
}
// Check for diagonal conflicts.
if (!(noDiagonalTrackConflicts(location, oldTrackPiece
.getTrackGraphicID(), w) && noDiagonalTrackConflicts(location,
newTrackPiece.getTrackGraphicID(), w))) {
return MoveStatus
.moveFailed("Illegal track configuration - diagonal conflict");
}
int terrainType = ((FreerailsTile) w.getTile(location.x, location.y))
.getTerrainTypeID();
TerrainType tt = (TerrainType) w.get(SKEY.TERRAIN_TYPES, terrainType);
if (!newTrackPiece.getTrackRule().canBuildOnThisTerrainType(
tt.getCategory())) {
String thisTrackType = newTrackPiece.getTrackRule().getTypeName();
String terrainCategory = tt.getCategory().toString().toLowerCase();
return MoveStatus.moveFailed("Can't build " + thisTrackType
+ " on " + terrainCategory);
}
// Check 4 overlapping stations.
if (newTrackPiece.getTrackRule().isStation()) {
MoveStatus ms = ChangeTrackPieceMove.check4overlap(w, location,
newTrackPiece);
if (!ms.ok)
return ms;
}
return MoveStatus.MOVE_OK;
}
public MoveStatus tryUndoMove(World w, FreerailsPrincipal p) {
return tryMove(w, this.trackPieceAfter, this.trackPieceBefore);
}
public MoveStatus doMove(World w, FreerailsPrincipal p) {
MoveStatus moveStatus = tryDoMove(w, p);
if (!moveStatus.isOk()) {
return moveStatus;
}
move(w, this.trackPieceBefore, this.trackPieceAfter);
return moveStatus;
}
private void move(World w, TrackPiece oldTrackPiece,
TrackPiece newTrackPiece) {
// FIXME why is oldTrackPiece not used???
FreerailsTile oldTile = (FreerailsTile) w.getTile(location.x,
location.y);
int terrain = oldTile.getTerrainTypeID();
FreerailsTile newTile = FreerailsTile.getInstance(terrain,
newTrackPiece);
w.setTile(location.x, location.y, newTile);
}
public MoveStatus undoMove(World w, FreerailsPrincipal p) {
MoveStatus moveStatus = tryUndoMove(w, p);
if (!moveStatus.isOk()) {
return moveStatus;
}
move(w, this.trackPieceAfter, this.trackPieceBefore);
return moveStatus;
}
private boolean noDiagonalTrackConflicts(ImPoint point, int trackTemplate,
World w) {
/*
* This method is needs replacing. It only deals with flat track pieces,
* and is rather hard to make sense of. LL
*/
// int trackTemplate = (1 << (3 * (1 + tv.getY()) + (1 + tv.getX())));
int trackTemplateAbove;
int trackTemplateBelow;
int cornersTemplate = TrackConfiguration
.stringTemplate2Int("101000101");
trackTemplate = trackTemplate & cornersTemplate;
Dimension mapSize = new Dimension(w.getMapWidth(), w.getMapHeight());
// Avoid array-out-of-bounds exceptions.
if (point.y > 0) {
FreerailsTile ft = (FreerailsTile)w.getTile(point.x, point.y - 1);
TrackPiece tp = ft.getTrackPiece();
trackTemplateAbove = tp.getTrackGraphicID();
} else {
trackTemplateAbove = 0;
}
if ((point.y + 1) < mapSize.height) {
FreerailsTile ft = (FreerailsTile)w.getTile(point.x, point.y + 1);
TrackPiece tp = ft.getTrackPiece();
trackTemplateBelow = tp.getTrackGraphicID();
} else {
trackTemplateBelow = 0;
}
trackTemplateAbove = trackTemplateAbove >> 6;
trackTemplateBelow = trackTemplateBelow << 6;
trackTemplate = trackTemplate
& (trackTemplateAbove | trackTemplateBelow);
if (trackTemplate != 0) {
return false;
// There is a clash.
}
return true;
// Things are ok.
}
public Rectangle getUpdatedTiles() {
// If we are building or removing a station,
// we need to repaint/remove the station radius
// that appears on the map.
int radius = 1;
TrackRule trackRuleAfter = this.trackPieceAfter.getTrackRule();
if (trackRuleAfter.isStation()) {
radius = Math.max(radius, trackRuleAfter.getStationRadius());
}
TrackRule trackRuleBefore = this.trackPieceBefore.getTrackRule();
if (trackRuleBefore.isStation()) {
radius = Math.max(radius, trackRuleBefore.getStationRadius());
}
// Just to be safe.
radius++;
int x;
int y;
int width;
int height;
x = location.x - radius;
y = location.y - radius;
width = radius * 2 + 1;
height = radius * 2 + 1;
return new Rectangle(x, y, width, height);
}
@Override
public boolean equals(Object o) {
if (o instanceof ChangeTrackPieceMove) {
ChangeTrackPieceMove m = (ChangeTrackPieceMove) o;
boolean fieldPointEqual = this.location.equals(m.location);
boolean fieldoldTrackPieceEqual = this.trackPieceBefore
.equals(m.trackPieceBefore);
boolean fieldnewTrackPieceEqual = this.trackPieceAfter
.equals(m.trackPieceAfter);
if (fieldPointEqual && fieldoldTrackPieceEqual
&& fieldnewTrackPieceEqual) {
return true;
}
return false;
}
return false;
}
protected static boolean canConnect2OtherRRsTrack(ReadOnlyWorld world) {
GameRules rules = (GameRules) world.get(ITEM.GAME_RULES);
return rules.isCanConnect2OtherRRTrack();
}
/**
* This method may be called under 3 possible conditions: (1) when a station
* is getting built, (2) when a station is getting upgraded, (3) when a
* station is getting removed.
*/
protected static MoveStatus check4overlap(World w, ImPoint location,
TrackPiece trackPiece) {
/*
* Fix for 915945 (Stations should not overlap) Check that there is not
* another station whose radius overlaps with the one we are building.
*/
TrackRule thisStationType = trackPiece.getTrackRule();
assert thisStationType.isStation();
for (int player = 0; player < w.getNumberOfPlayers(); player++) {
FreerailsPrincipal principal = w.getPlayer(player).getPrincipal();
WorldIterator wi = new NonNullElements(KEY.STATIONS, w, principal);
while (wi.next()) {
StationModel station = (StationModel) wi.getElement();
/*
* Fix for bug 948675 - Can't upgrade station types If locations
* are the same, then we are upgrading a station so it doesn't
* matter if the radii overlap.
*/
if (location.x == station.x && location.y == station.y) {
continue;
}
FreerailsTile tile = (FreerailsTile) w.getTile(station.x,
station.y);
TrackRule otherStationType = tile.getTrackPiece().getTrackRule();
assert otherStationType.isStation();
int sumOfRadii = otherStationType.getStationRadius()
+ thisStationType.getStationRadius();
int sumOfRadiiSquared = sumOfRadii * sumOfRadii;
int xDistance = station.x - location.x;
int yDistance = station.y - location.y;
// Do radii overlap?
boolean xOverlap = sumOfRadiiSquared >= (xDistance * xDistance);
boolean yOverlap = sumOfRadiiSquared >= (yDistance * yDistance);
if (xOverlap && yOverlap) {
String message = "Too close to " + station.getStationName();
return MoveStatus.moveFailed(message);
}
}
}
return MoveStatus.MOVE_OK;
}
}